1 /* symbols.c -symbol table-
2 Copyright (C) 1987-2020 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" */
38 /* Whether the symbol is a local_symbol. */
39 unsigned int local_symbol
: 1;
41 /* Weather symbol has been written. */
42 unsigned int written
: 1;
44 /* Whether symbol value has been completely resolved (used during
45 final pass over symbol table). */
46 unsigned int resolved
: 1;
48 /* Whether the symbol value is currently being resolved (used to
49 detect loops in symbol dependencies). */
50 unsigned int resolving
: 1;
52 /* Whether the symbol value is used in a reloc. This is used to
53 ensure that symbols used in relocs are written out, even if they
54 are local and would otherwise not be. */
55 unsigned int used_in_reloc
: 1;
57 /* Whether the symbol is used as an operand or in an expression.
58 NOTE: Not all the backends keep this information accurate;
59 backends which use this bit are responsible for setting it when
60 a symbol is used in backend routines. */
61 unsigned int used
: 1;
63 /* Whether the symbol can be re-defined. */
64 unsigned int volatil
: 1;
66 /* Whether the symbol is a forward reference. */
67 unsigned int forward_ref
: 1;
69 /* This is set if the symbol is defined in an MRI common section.
70 We handle such sections as single common symbols, so symbols
71 defined within them must be treated specially by the relocation
73 unsigned int mri_common
: 1;
75 /* This is set if the symbol is set with a .weakref directive. */
76 unsigned int weakrefr
: 1;
78 /* This is set when the symbol is referenced as part of a .weakref
79 directive, but only if the symbol was not in the symbol table
80 before. It is cleared as soon as any direct reference to the
82 unsigned int weakrefd
: 1;
85 /* A pointer in the symbol may point to either a complete symbol
86 (struct symbol below) or to a local symbol (struct local_symbol
87 defined here). The symbol code can detect the case by examining
88 the first field which is present in both structs.
90 We do this because we ordinarily only need a small amount of
91 information for a local symbol. The symbol table takes up a lot of
92 space, and storing less information for a local symbol can make a
93 big difference in assembler memory usage when assembling a large
98 /* Symbol flags. Only local_symbol and resolved are relevant. */
99 struct symbol_flags flags
;
101 /* Hash value calculated from name. */
104 /* The symbol name. */
107 /* The symbol frag. */
110 /* The symbol section. */
113 /* The value of the symbol. */
117 /* The information we keep for a symbol. The symbol table holds
118 pointers both to this and to local_symbol structures. The first
119 three fields must be identical to struct local_symbol, and the size
120 should be the same as or smaller than struct local_symbol.
121 Fields that don't fit go to an extension structure. */
126 struct symbol_flags flags
;
128 /* Hash value calculated from name. */
131 /* The symbol name. */
134 /* Pointer to the frag this symbol is attached to, if any.
141 /* Extra symbol fields that won't fit. */
145 /* Extra fields to make up a full symbol. */
149 /* The value of the symbol. */
152 /* Forwards and backwards chain pointers. */
154 struct symbol
*previous
;
156 #ifdef OBJ_SYMFIELD_TYPE
157 OBJ_SYMFIELD_TYPE obj
;
160 #ifdef TC_SYMFIELD_TYPE
165 typedef union symbol_entry
167 struct local_symbol lsy
;
171 /* Hash function for a symbol_entry. */
174 hash_symbol_entry (const void *e
)
176 symbol_entry_t
*entry
= (symbol_entry_t
*) e
;
177 if (entry
->sy
.hash
== 0)
178 entry
->sy
.hash
= htab_hash_string (entry
->sy
.name
);
180 return entry
->sy
.hash
;
183 /* Equality function for a symbol_entry. */
186 eq_symbol_entry (const void *a
, const void *b
)
188 const symbol_entry_t
*ea
= (const symbol_entry_t
*) a
;
189 const symbol_entry_t
*eb
= (const symbol_entry_t
*) b
;
191 return (ea
->sy
.hash
== eb
->sy
.hash
192 && strcmp (ea
->sy
.name
, eb
->sy
.name
) == 0);
196 symbol_entry_find (htab_t table
, const char *name
)
198 hashval_t hash
= htab_hash_string (name
);
199 symbol_entry_t needle
= { { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
200 hash
, name
, 0, 0, 0 } };
201 return htab_find_with_hash (table
, &needle
, hash
);
205 /* This is non-zero if symbols are case sensitive, which is the
207 int symbols_case_sensitive
= 1;
209 #ifndef WORKING_DOT_WORD
210 extern int new_broken_words
;
213 static htab_t sy_hash
;
215 /* Below are commented in "symbols.h". */
216 symbolS
*symbol_rootP
;
217 symbolS
*symbol_lastP
;
219 struct xsymbol abs_symbol_x
;
221 struct xsymbol dot_symbol_x
;
224 #define debug_verify_symchain verify_symbol_chain
226 #define debug_verify_symchain(root, last) ((void) 0)
229 #define DOLLAR_LABEL_CHAR '\001'
230 #define LOCAL_LABEL_CHAR '\002'
232 #ifndef TC_LABEL_IS_LOCAL
233 #define TC_LABEL_IS_LOCAL(name) 0
236 struct obstack notes
;
238 /* The name of an external symbol which is
239 used to make weak PE symbol names unique. */
240 const char * an_external_name
;
243 static const char *save_symbol_name (const char *);
244 static void fb_label_init (void);
245 static long dollar_label_instance (long);
246 static long fb_label_instance (long);
248 static void print_binary (FILE *, const char *, expressionS
*);
250 /* Return a pointer to a new symbol. Die if we can't make a new
251 symbol. Fill in the symbol's values. Add symbol to end of symbol
254 This function should be called in the general case of creating a
255 symbol. However, if the output file symbol table has already been
256 set, and you are certain that this symbol won't be wanted in the
257 output file, you can call symbol_create. */
260 symbol_new (const char *name
, segT segment
, fragS
*frag
, valueT valu
)
262 symbolS
*symbolP
= symbol_create (name
, segment
, frag
, valu
);
264 /* Link to end of symbol chain. */
265 symbol_append (symbolP
, symbol_lastP
, &symbol_rootP
, &symbol_lastP
);
270 /* Save a symbol name on a permanent obstack, and convert it according
271 to the object file format. */
274 save_symbol_name (const char *name
)
279 gas_assert (name
!= NULL
);
280 name_length
= strlen (name
) + 1; /* +1 for \0. */
281 obstack_grow (¬es
, name
, name_length
);
282 ret
= (char *) obstack_finish (¬es
);
284 #ifdef tc_canonicalize_symbol_name
285 ret
= tc_canonicalize_symbol_name (ret
);
288 if (! symbols_case_sensitive
)
292 for (s
= ret
; *s
!= '\0'; s
++)
300 symbol_init (symbolS
*symbolP
, const char *name
, asection
*sec
,
301 fragS
*frag
, valueT valu
)
303 symbolP
->frag
= frag
;
304 symbolP
->bsym
= bfd_make_empty_symbol (stdoutput
);
305 if (symbolP
->bsym
== NULL
)
306 as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));
307 symbolP
->bsym
->name
= name
;
308 symbolP
->bsym
->section
= sec
;
310 S_SET_VALUE (symbolP
, valu
);
312 symbol_clear_list_pointers (symbolP
);
314 obj_symbol_new_hook (symbolP
);
316 #ifdef tc_symbol_new_hook
317 tc_symbol_new_hook (symbolP
);
321 /* Create a symbol. NAME is copied, the caller can destroy/modify. */
324 symbol_create (const char *name
, segT segment
, fragS
*frag
, valueT valu
)
326 const char *preserved_copy_of_name
;
330 preserved_copy_of_name
= save_symbol_name (name
);
332 size
= sizeof (symbolS
) + sizeof (struct xsymbol
);
333 symbolP
= (symbolS
*) obstack_alloc (¬es
, size
);
335 /* symbol must be born in some fixed state. This seems as good as any. */
336 memset (symbolP
, 0, size
);
337 symbolP
->name
= preserved_copy_of_name
;
338 symbolP
->x
= (struct xsymbol
*) (symbolP
+ 1);
340 symbol_init (symbolP
, preserved_copy_of_name
, segment
, frag
, valu
);
346 /* Local symbol support. If we can get away with it, we keep only a
347 small amount of information for local symbols. */
349 /* Used for statistics. */
351 static unsigned long local_symbol_count
;
352 static unsigned long local_symbol_conversion_count
;
354 /* Create a local symbol and insert it into the local hash table. */
356 struct local_symbol
*
357 local_symbol_make (const char *name
, segT section
, fragS
*frag
, valueT val
)
359 const char *name_copy
;
360 struct local_symbol
*ret
;
361 struct symbol_flags flags
= { .local_symbol
= 1, .resolved
= 0 };
363 ++local_symbol_count
;
365 name_copy
= save_symbol_name (name
);
367 ret
= (struct local_symbol
*) obstack_alloc (¬es
, sizeof *ret
);
370 ret
->name
= name_copy
;
372 ret
->section
= section
;
375 htab_insert (sy_hash
, ret
, 1);
380 /* Convert a local symbol into a real symbol. */
383 local_symbol_convert (void *sym
)
385 symbol_entry_t
*ent
= (symbol_entry_t
*) sym
;
386 struct xsymbol
*xtra
;
389 gas_assert (ent
->lsy
.flags
.local_symbol
);
391 ++local_symbol_conversion_count
;
393 xtra
= (struct xsymbol
*) obstack_alloc (¬es
, sizeof (*xtra
));
394 memset (xtra
, 0, sizeof (*xtra
));
395 val
= ent
->lsy
.value
;
398 /* Local symbols are always either defined or used. */
399 ent
->sy
.flags
.used
= 1;
400 ent
->sy
.flags
.local_symbol
= 0;
402 symbol_init (&ent
->sy
, ent
->lsy
.name
, ent
->lsy
.section
, ent
->lsy
.frag
, val
);
403 symbol_append (&ent
->sy
, symbol_lastP
, &symbol_rootP
, &symbol_lastP
);
409 define_sym_at_dot (symbolS
*symbolP
)
411 symbolP
->frag
= frag_now
;
412 S_SET_VALUE (symbolP
, (valueT
) frag_now_fix ());
413 S_SET_SEGMENT (symbolP
, now_seg
);
416 /* We have just seen "<name>:".
417 Creates a struct symbol unless it already exists.
419 Gripes if we are redefining a symbol incompatibly (and ignores it). */
422 colon (/* Just seen "x:" - rattle symbols & frags. */
423 const char *sym_name
/* Symbol name, as a canonical string. */
424 /* We copy this string: OK to alter later. */)
426 symbolS
*symbolP
; /* Symbol we are working with. */
428 /* Sun local labels go out of scope whenever a non-local symbol is
430 if (LOCAL_LABELS_DOLLAR
431 && !bfd_is_local_label_name (stdoutput
, sym_name
))
432 dollar_label_clear ();
434 #ifndef WORKING_DOT_WORD
435 if (new_broken_words
)
437 struct broken_word
*a
;
442 if (now_seg
== absolute_section
)
444 as_bad (_("cannot define symbol `%s' in absolute section"), sym_name
);
448 possible_bytes
= (md_short_jump_size
449 + new_broken_words
* md_long_jump_size
);
452 frag_opcode
= frag_var (rs_broken_word
,
456 (symbolS
*) broken_words
,
460 /* We want to store the pointer to where to insert the jump
461 table in the fr_opcode of the rs_broken_word frag. This
462 requires a little hackery. */
464 && (frag_tmp
->fr_type
!= rs_broken_word
465 || frag_tmp
->fr_opcode
))
466 frag_tmp
= frag_tmp
->fr_next
;
468 frag_tmp
->fr_opcode
= frag_opcode
;
469 new_broken_words
= 0;
471 for (a
= broken_words
; a
&& a
->dispfrag
== 0; a
= a
->next_broken_word
)
472 a
->dispfrag
= frag_tmp
;
474 #endif /* WORKING_DOT_WORD */
476 #ifdef obj_frob_colon
477 obj_frob_colon (sym_name
);
480 if ((symbolP
= symbol_find (sym_name
)) != 0)
482 S_CLEAR_WEAKREFR (symbolP
);
483 #ifdef RESOLVE_SYMBOL_REDEFINITION
484 if (RESOLVE_SYMBOL_REDEFINITION (symbolP
))
487 /* Now check for undefined symbols. */
488 if (symbolP
->flags
.local_symbol
)
490 struct local_symbol
*locsym
= (struct local_symbol
*) symbolP
;
492 if (locsym
->section
!= undefined_section
493 && (locsym
->frag
!= frag_now
494 || locsym
->section
!= now_seg
495 || locsym
->value
!= frag_now_fix ()))
497 as_bad (_("symbol `%s' is already defined"), sym_name
);
501 locsym
->section
= now_seg
;
502 locsym
->frag
= frag_now
;
503 locsym
->value
= frag_now_fix ();
505 else if (!(S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
506 || S_IS_COMMON (symbolP
)
507 || S_IS_VOLATILE (symbolP
))
509 if (S_IS_VOLATILE (symbolP
))
511 symbolP
= symbol_clone (symbolP
, 1);
512 S_SET_VALUE (symbolP
, 0);
513 S_CLEAR_VOLATILE (symbolP
);
515 if (S_GET_VALUE (symbolP
) == 0)
517 define_sym_at_dot (symbolP
);
520 #endif /* if we have one, it better be zero. */
525 /* There are still several cases to check:
527 A .comm/.lcomm symbol being redefined as initialized
530 A .comm/.lcomm symbol being redefined with a larger
533 This only used to be allowed on VMS gas, but Sun cc
534 on the sparc also depends on it. */
536 if (((!S_IS_DEBUG (symbolP
)
537 && (!S_IS_DEFINED (symbolP
) || S_IS_COMMON (symbolP
))
538 && S_IS_EXTERNAL (symbolP
))
539 || S_GET_SEGMENT (symbolP
) == bss_section
)
540 && (now_seg
== data_section
541 || now_seg
== bss_section
542 || now_seg
== S_GET_SEGMENT (symbolP
)))
544 /* Select which of the 2 cases this is. */
545 if (now_seg
!= data_section
)
547 /* New .comm for prev .comm symbol.
549 If the new size is larger we just change its
550 value. If the new size is smaller, we ignore
552 if (S_GET_VALUE (symbolP
)
553 < ((unsigned) frag_now_fix ()))
555 S_SET_VALUE (symbolP
, (valueT
) frag_now_fix ());
560 /* It is a .comm/.lcomm being converted to initialized
562 define_sym_at_dot (symbolP
);
567 #if (!defined (OBJ_AOUT) && !defined (OBJ_MAYBE_AOUT))
568 static const char *od_buf
= "";
572 if (OUTPUT_FLAVOR
== bfd_target_aout_flavour
)
573 sprintf (od_buf
, "%d.%d.",
574 S_GET_OTHER (symbolP
),
575 S_GET_DESC (symbolP
));
577 as_bad (_("symbol `%s' is already defined as \"%s\"/%s%ld"),
579 segment_name (S_GET_SEGMENT (symbolP
)),
581 (long) S_GET_VALUE (symbolP
));
583 } /* if the undefined symbol has no value */
587 /* Don't blow up if the definition is the same. */
588 if (!(frag_now
== symbolP
->frag
589 && S_GET_VALUE (symbolP
) == frag_now_fix ()
590 && S_GET_SEGMENT (symbolP
) == now_seg
))
592 as_bad (_("symbol `%s' is already defined"), sym_name
);
593 symbolP
= symbol_clone (symbolP
, 0);
594 define_sym_at_dot (symbolP
);
599 else if (! flag_keep_locals
&& bfd_is_local_label_name (stdoutput
, sym_name
))
601 symbolP
= (symbolS
*) local_symbol_make (sym_name
, now_seg
, frag_now
,
606 symbolP
= symbol_new (sym_name
, now_seg
, frag_now
, frag_now_fix ());
608 symbol_table_insert (symbolP
);
611 if (mri_common_symbol
!= NULL
)
613 /* This symbol is actually being defined within an MRI common
614 section. This requires special handling. */
615 if (symbolP
->flags
.local_symbol
)
616 symbolP
= local_symbol_convert (symbolP
);
617 symbolP
->x
->value
.X_op
= O_symbol
;
618 symbolP
->x
->value
.X_add_symbol
= mri_common_symbol
;
619 symbolP
->x
->value
.X_add_number
= S_GET_VALUE (mri_common_symbol
);
620 symbolP
->frag
= &zero_address_frag
;
621 S_SET_SEGMENT (symbolP
, expr_section
);
622 symbolP
->flags
.mri_common
= 1;
626 tc_frob_label (symbolP
);
628 #ifdef obj_frob_label
629 obj_frob_label (symbolP
);
635 /* Die if we can't insert the symbol. */
638 symbol_table_insert (symbolS
*symbolP
)
642 htab_insert (sy_hash
, symbolP
, 1);
645 /* If a symbol name does not exist, create it as undefined, and insert
646 it into the symbol table. Return a pointer to it. */
649 symbol_find_or_make (const char *name
)
653 symbolP
= symbol_find (name
);
657 if (! flag_keep_locals
&& bfd_is_local_label_name (stdoutput
, name
))
659 symbolP
= md_undefined_symbol ((char *) name
);
663 symbolP
= (symbolS
*) local_symbol_make (name
, undefined_section
,
664 &zero_address_frag
, 0);
668 symbolP
= symbol_make (name
);
670 symbol_table_insert (symbolP
);
671 } /* if symbol wasn't found */
677 symbol_make (const char *name
)
681 /* Let the machine description default it, e.g. for register names. */
682 symbolP
= md_undefined_symbol ((char *) name
);
685 symbolP
= symbol_new (name
, undefined_section
, &zero_address_frag
, 0);
691 symbol_clone (symbolS
*orgsymP
, int replace
)
694 asymbol
*bsymorg
, *bsymnew
;
696 /* Make sure we never clone the dot special symbol. */
697 gas_assert (orgsymP
!= &dot_symbol
);
699 /* When cloning a local symbol it isn't absolutely necessary to
700 convert the original, but converting makes the code much
701 simpler to cover this unexpected case. As of 2020-08-21
702 symbol_clone won't be called on a local symbol. */
703 if (orgsymP
->flags
.local_symbol
)
704 orgsymP
= local_symbol_convert (orgsymP
);
705 bsymorg
= orgsymP
->bsym
;
707 newsymP
= (symbolS
*) obstack_alloc (¬es
, (sizeof (symbolS
)
708 + sizeof (struct xsymbol
)));
710 newsymP
->x
= (struct xsymbol
*) (newsymP
+ 1);
711 *newsymP
->x
= *orgsymP
->x
;
712 bsymnew
= bfd_make_empty_symbol (bfd_asymbol_bfd (bsymorg
));
714 as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));
715 newsymP
->bsym
= bsymnew
;
716 bsymnew
->name
= bsymorg
->name
;
717 bsymnew
->flags
= bsymorg
->flags
& ~BSF_SECTION_SYM
;
718 bsymnew
->section
= bsymorg
->section
;
719 bfd_copy_private_symbol_data (bfd_asymbol_bfd (bsymorg
), bsymorg
,
720 bfd_asymbol_bfd (bsymnew
), bsymnew
);
722 #ifdef obj_symbol_clone_hook
723 obj_symbol_clone_hook (newsymP
, orgsymP
);
726 #ifdef tc_symbol_clone_hook
727 tc_symbol_clone_hook (newsymP
, orgsymP
);
732 if (symbol_rootP
== orgsymP
)
733 symbol_rootP
= newsymP
;
734 else if (orgsymP
->x
->previous
)
736 orgsymP
->x
->previous
->x
->next
= newsymP
;
737 orgsymP
->x
->previous
= NULL
;
739 if (symbol_lastP
== orgsymP
)
740 symbol_lastP
= newsymP
;
741 else if (orgsymP
->x
->next
)
742 orgsymP
->x
->next
->x
->previous
= newsymP
;
744 /* Symbols that won't be output can't be external. */
745 S_CLEAR_EXTERNAL (orgsymP
);
746 orgsymP
->x
->previous
= orgsymP
->x
->next
= orgsymP
;
747 debug_verify_symchain (symbol_rootP
, symbol_lastP
);
749 symbol_table_insert (newsymP
);
753 /* Symbols that won't be output can't be external. */
754 S_CLEAR_EXTERNAL (newsymP
);
755 newsymP
->x
->previous
= newsymP
->x
->next
= newsymP
;
761 /* Referenced symbols, if they are forward references, need to be cloned
762 (without replacing the original) so that the value of the referenced
763 symbols at the point of use is saved by the clone. */
765 #undef symbol_clone_if_forward_ref
767 symbol_clone_if_forward_ref (symbolS
*symbolP
, int is_forward
)
769 if (symbolP
&& !symbolP
->flags
.local_symbol
)
771 symbolS
*orig_add_symbol
= symbolP
->x
->value
.X_add_symbol
;
772 symbolS
*orig_op_symbol
= symbolP
->x
->value
.X_op_symbol
;
773 symbolS
*add_symbol
= orig_add_symbol
;
774 symbolS
*op_symbol
= orig_op_symbol
;
776 if (symbolP
->flags
.forward_ref
)
781 /* assign_symbol() clones volatile symbols; pre-existing expressions
782 hold references to the original instance, but want the current
783 value. Just repeat the lookup. */
784 if (add_symbol
&& S_IS_VOLATILE (add_symbol
))
785 add_symbol
= symbol_find_exact (S_GET_NAME (add_symbol
));
786 if (op_symbol
&& S_IS_VOLATILE (op_symbol
))
787 op_symbol
= symbol_find_exact (S_GET_NAME (op_symbol
));
790 /* Re-using resolving here, as this routine cannot get called from
791 symbol resolution code. */
792 if ((symbolP
->bsym
->section
== expr_section
793 || symbolP
->flags
.forward_ref
)
794 && !symbolP
->flags
.resolving
)
796 symbolP
->flags
.resolving
= 1;
797 add_symbol
= symbol_clone_if_forward_ref (add_symbol
, is_forward
);
798 op_symbol
= symbol_clone_if_forward_ref (op_symbol
, is_forward
);
799 symbolP
->flags
.resolving
= 0;
802 if (symbolP
->flags
.forward_ref
803 || add_symbol
!= orig_add_symbol
804 || op_symbol
!= orig_op_symbol
)
806 if (symbolP
!= &dot_symbol
)
808 symbolP
= symbol_clone (symbolP
, 0);
809 symbolP
->flags
.resolving
= 0;
813 symbolP
= symbol_temp_new_now ();
814 #ifdef tc_new_dot_label
815 tc_new_dot_label (symbolP
);
820 symbolP
->x
->value
.X_add_symbol
= add_symbol
;
821 symbolP
->x
->value
.X_op_symbol
= op_symbol
;
828 symbol_temp_new (segT seg
, fragS
*frag
, valueT ofs
)
830 return symbol_new (FAKE_LABEL_NAME
, seg
, frag
, ofs
);
834 symbol_temp_new_now (void)
836 return symbol_temp_new (now_seg
, frag_now
, frag_now_fix ());
840 symbol_temp_new_now_octets (void)
842 return symbol_temp_new (now_seg
, frag_now
, frag_now_fix_octets ());
846 symbol_temp_make (void)
848 return symbol_make (FAKE_LABEL_NAME
);
851 /* Implement symbol table lookup.
852 In: A symbol's name as a string: '\0' can't be part of a symbol name.
853 Out: NULL if the name was not in the symbol table, else the address
854 of a struct symbol associated with that name. */
857 symbol_find_exact (const char *name
)
859 return symbol_find_exact_noref (name
, 0);
863 symbol_find_exact_noref (const char *name
, int noref
)
865 symbolS
*sym
= symbol_entry_find (sy_hash
, name
);
867 /* Any references to the symbol, except for the reference in
868 .weakref, must clear this flag, such that the symbol does not
869 turn into a weak symbol. Note that we don't have to handle the
870 local_symbol case, since a weakrefd is always promoted out of the
871 local_symbol table when it is turned into a weak symbol. */
873 S_CLEAR_WEAKREFD (sym
);
879 symbol_find (const char *name
)
881 return symbol_find_noref (name
, 0);
885 symbol_find_noref (const char *name
, int noref
)
890 #ifdef tc_canonicalize_symbol_name
892 copy
= xstrdup (name
);
893 name
= tc_canonicalize_symbol_name (copy
);
897 if (! symbols_case_sensitive
)
906 name
= copy
= XNEWVEC (char, strlen (name
) + 1);
908 while ((c
= *orig
++) != '\0')
909 *copy
++ = TOUPPER (c
);
913 copy
= (char *) name
;
916 result
= symbol_find_exact_noref (name
, noref
);
921 /* Once upon a time, symbols were kept in a singly linked list. At
922 least coff needs to be able to rearrange them from time to time, for
923 which a doubly linked list is much more convenient. Loic did these
924 as macros which seemed dangerous to me so they're now functions.
927 /* Link symbol ADDME after symbol TARGET in the chain. */
930 symbol_append (symbolS
*addme
, symbolS
*target
,
931 symbolS
**rootPP
, symbolS
**lastPP
)
933 extern int symbol_table_frozen
;
934 if (symbol_table_frozen
)
936 if (addme
->flags
.local_symbol
)
938 if (target
!= NULL
&& target
->flags
.local_symbol
)
943 know (*rootPP
== NULL
);
944 know (*lastPP
== NULL
);
945 addme
->x
->next
= NULL
;
946 addme
->x
->previous
= NULL
;
950 } /* if the list is empty */
952 if (target
->x
->next
!= NULL
)
954 target
->x
->next
->x
->previous
= addme
;
958 know (*lastPP
== target
);
960 } /* if we have a next */
962 addme
->x
->next
= target
->x
->next
;
963 target
->x
->next
= addme
;
964 addme
->x
->previous
= target
;
966 debug_verify_symchain (symbol_rootP
, symbol_lastP
);
969 /* Set the chain pointers of SYMBOL to null. */
972 symbol_clear_list_pointers (symbolS
*symbolP
)
974 if (symbolP
->flags
.local_symbol
)
976 symbolP
->x
->next
= NULL
;
977 symbolP
->x
->previous
= NULL
;
980 /* Remove SYMBOLP from the list. */
983 symbol_remove (symbolS
*symbolP
, symbolS
**rootPP
, symbolS
**lastPP
)
985 if (symbolP
->flags
.local_symbol
)
988 if (symbolP
== *rootPP
)
990 *rootPP
= symbolP
->x
->next
;
991 } /* if it was the root */
993 if (symbolP
== *lastPP
)
995 *lastPP
= symbolP
->x
->previous
;
996 } /* if it was the tail */
998 if (symbolP
->x
->next
!= NULL
)
1000 symbolP
->x
->next
->x
->previous
= symbolP
->x
->previous
;
1003 if (symbolP
->x
->previous
!= NULL
)
1005 symbolP
->x
->previous
->x
->next
= symbolP
->x
->next
;
1006 } /* if not first */
1008 debug_verify_symchain (*rootPP
, *lastPP
);
1011 /* Link symbol ADDME before symbol TARGET in the chain. */
1014 symbol_insert (symbolS
*addme
, symbolS
*target
,
1015 symbolS
**rootPP
, symbolS
**lastPP ATTRIBUTE_UNUSED
)
1017 extern int symbol_table_frozen
;
1018 if (symbol_table_frozen
)
1020 if (addme
->flags
.local_symbol
)
1022 if (target
->flags
.local_symbol
)
1025 if (target
->x
->previous
!= NULL
)
1027 target
->x
->previous
->x
->next
= addme
;
1031 know (*rootPP
== target
);
1033 } /* if not first */
1035 addme
->x
->previous
= target
->x
->previous
;
1036 target
->x
->previous
= addme
;
1037 addme
->x
->next
= target
;
1039 debug_verify_symchain (*rootPP
, *lastPP
);
1043 verify_symbol_chain (symbolS
*rootP
, symbolS
*lastP
)
1045 symbolS
*symbolP
= rootP
;
1047 if (symbolP
== NULL
)
1050 for (; symbol_next (symbolP
) != NULL
; symbolP
= symbol_next (symbolP
))
1052 gas_assert (symbolP
->bsym
!= NULL
);
1053 gas_assert (symbolP
->flags
.local_symbol
== 0);
1054 gas_assert (symbolP
->x
->next
->x
->previous
== symbolP
);
1057 gas_assert (lastP
== symbolP
);
1061 symbol_on_chain (symbolS
*s
, symbolS
*rootPP
, symbolS
*lastPP
)
1063 return (!s
->flags
.local_symbol
1064 && ((s
->x
->next
!= s
1065 && s
->x
->next
!= NULL
1066 && s
->x
->next
->x
->previous
== s
)
1068 && ((s
->x
->previous
!= s
1069 && s
->x
->previous
!= NULL
1070 && s
->x
->previous
->x
->next
== s
)
1074 #ifdef OBJ_COMPLEX_RELC
1077 use_complex_relocs_for (symbolS
* symp
)
1079 switch (symp
->x
->value
.X_op
)
1089 case O_bit_inclusive_or
:
1091 case O_bit_exclusive_or
:
1103 if ((S_IS_COMMON (symp
->x
->value
.X_op_symbol
)
1104 || S_IS_LOCAL (symp
->x
->value
.X_op_symbol
))
1105 && S_IS_DEFINED (symp
->x
->value
.X_op_symbol
)
1106 && S_GET_SEGMENT (symp
->x
->value
.X_op_symbol
) != expr_section
)
1113 if ((S_IS_COMMON (symp
->x
->value
.X_add_symbol
)
1114 || S_IS_LOCAL (symp
->x
->value
.X_add_symbol
))
1115 && S_IS_DEFINED (symp
->x
->value
.X_add_symbol
)
1116 && S_GET_SEGMENT (symp
->x
->value
.X_add_symbol
) != expr_section
)
1129 report_op_error (symbolS
*symp
, symbolS
*left
, operatorT op
, symbolS
*right
)
1133 segT seg_left
= left
? S_GET_SEGMENT (left
) : 0;
1134 segT seg_right
= S_GET_SEGMENT (right
);
1143 case O_uminus
: opname
= "-"; break;
1144 case O_bit_not
: opname
= "~"; break;
1145 case O_logical_not
: opname
= "!"; break;
1146 case O_multiply
: opname
= "*"; break;
1147 case O_divide
: opname
= "/"; break;
1148 case O_modulus
: opname
= "%"; break;
1149 case O_left_shift
: opname
= "<<"; break;
1150 case O_right_shift
: opname
= ">>"; break;
1151 case O_bit_inclusive_or
: opname
= "|"; break;
1152 case O_bit_or_not
: opname
= "|~"; break;
1153 case O_bit_exclusive_or
: opname
= "^"; break;
1154 case O_bit_and
: opname
= "&"; break;
1155 case O_add
: opname
= "+"; break;
1156 case O_subtract
: opname
= "-"; break;
1157 case O_eq
: opname
= "=="; break;
1158 case O_ne
: opname
= "!="; break;
1159 case O_lt
: opname
= "<"; break;
1160 case O_le
: opname
= "<="; break;
1161 case O_ge
: opname
= ">="; break;
1162 case O_gt
: opname
= ">"; break;
1163 case O_logical_and
: opname
= "&&"; break;
1164 case O_logical_or
: opname
= "||"; break;
1167 if (expr_symbol_where (symp
, &file
, &line
))
1170 as_bad_where (file
, line
,
1171 _("invalid operands (%s and %s sections) for `%s'"),
1172 seg_left
->name
, seg_right
->name
, opname
);
1174 as_bad_where (file
, line
,
1175 _("invalid operand (%s section) for `%s'"),
1176 seg_right
->name
, opname
);
1180 const char *sname
= S_GET_NAME (symp
);
1183 as_bad (_("invalid operands (%s and %s sections) for `%s' when setting `%s'"),
1184 seg_left
->name
, seg_right
->name
, opname
, sname
);
1186 as_bad (_("invalid operand (%s section) for `%s' when setting `%s'"),
1187 seg_right
->name
, opname
, sname
);
1191 /* Resolve the value of a symbol. This is called during the final
1192 pass over the symbol table to resolve any symbols with complex
1196 resolve_symbol_value (symbolS
*symp
)
1202 if (symp
->flags
.local_symbol
)
1204 struct local_symbol
*locsym
= (struct local_symbol
*) symp
;
1206 final_val
= locsym
->value
;
1207 if (locsym
->flags
.resolved
)
1210 /* Symbols whose section has SEC_ELF_OCTETS set,
1211 resolve to octets instead of target bytes. */
1212 if (locsym
->section
->flags
& SEC_OCTETS
)
1213 final_val
+= locsym
->frag
->fr_address
;
1215 final_val
+= locsym
->frag
->fr_address
/ OCTETS_PER_BYTE
;
1219 locsym
->value
= final_val
;
1220 locsym
->flags
.resolved
= 1;
1226 if (symp
->flags
.resolved
)
1229 while (symp
->x
->value
.X_op
== O_symbol
)
1231 final_val
+= symp
->x
->value
.X_add_number
;
1232 symp
= symp
->x
->value
.X_add_symbol
;
1233 if (symp
->flags
.local_symbol
)
1235 struct local_symbol
*locsym
= (struct local_symbol
*) symp
;
1236 final_val
+= locsym
->value
;
1239 if (!symp
->flags
.resolved
)
1242 if (symp
->x
->value
.X_op
== O_constant
)
1243 final_val
+= symp
->x
->value
.X_add_number
;
1250 final_seg
= S_GET_SEGMENT (symp
);
1252 if (symp
->flags
.resolving
)
1255 as_bad (_("symbol definition loop encountered at `%s'"),
1260 #ifdef OBJ_COMPLEX_RELC
1261 else if (final_seg
== expr_section
1262 && use_complex_relocs_for (symp
))
1264 symbolS
* relc_symbol
= NULL
;
1265 char * relc_symbol_name
= NULL
;
1267 relc_symbol_name
= symbol_relc_make_expr (& symp
->x
->value
);
1269 /* For debugging, print out conversion input & output. */
1271 print_expr (& symp
->x
->value
);
1272 if (relc_symbol_name
)
1273 fprintf (stderr
, "-> relc symbol: %s\n", relc_symbol_name
);
1276 if (relc_symbol_name
!= NULL
)
1277 relc_symbol
= symbol_new (relc_symbol_name
, undefined_section
,
1278 &zero_address_frag
, 0);
1280 if (relc_symbol
== NULL
)
1282 as_bad (_("cannot convert expression symbol %s to complex relocation"),
1288 symbol_table_insert (relc_symbol
);
1290 /* S_CLEAR_EXTERNAL (relc_symbol); */
1291 if (symp
->bsym
->flags
& BSF_SRELC
)
1292 relc_symbol
->bsym
->flags
|= BSF_SRELC
;
1294 relc_symbol
->bsym
->flags
|= BSF_RELC
;
1295 /* symp->bsym->flags |= BSF_RELC; */
1296 copy_symbol_attributes (symp
, relc_symbol
);
1297 symp
->x
->value
.X_op
= O_symbol
;
1298 symp
->x
->value
.X_add_symbol
= relc_symbol
;
1299 symp
->x
->value
.X_add_number
= 0;
1304 final_seg
= undefined_section
;
1305 goto exit_dont_set_value
;
1310 symbolS
*add_symbol
, *op_symbol
;
1311 offsetT left
, right
;
1312 segT seg_left
, seg_right
;
1316 symp
->flags
.resolving
= 1;
1318 /* Help out with CSE. */
1319 add_symbol
= symp
->x
->value
.X_add_symbol
;
1320 op_symbol
= symp
->x
->value
.X_op_symbol
;
1321 final_val
= symp
->x
->value
.X_add_number
;
1322 op
= symp
->x
->value
.X_op
;
1335 /* Symbols whose section has SEC_ELF_OCTETS set,
1336 resolve to octets instead of target bytes. */
1337 if (symp
->bsym
->section
->flags
& SEC_OCTETS
)
1338 final_val
+= symp
->frag
->fr_address
;
1340 final_val
+= symp
->frag
->fr_address
/ OCTETS_PER_BYTE
;
1341 if (final_seg
== expr_section
)
1342 final_seg
= absolute_section
;
1351 left
= resolve_symbol_value (add_symbol
);
1352 seg_left
= S_GET_SEGMENT (add_symbol
);
1354 symp
->x
->value
.X_op_symbol
= NULL
;
1357 if (S_IS_WEAKREFR (symp
))
1359 gas_assert (final_val
== 0);
1360 if (S_IS_WEAKREFR (add_symbol
))
1362 gas_assert (add_symbol
->x
->value
.X_op
== O_symbol
1363 && add_symbol
->x
->value
.X_add_number
== 0);
1364 add_symbol
= add_symbol
->x
->value
.X_add_symbol
;
1365 gas_assert (! S_IS_WEAKREFR (add_symbol
));
1366 symp
->x
->value
.X_add_symbol
= add_symbol
;
1370 if (symp
->flags
.mri_common
)
1372 /* This is a symbol inside an MRI common section. The
1373 relocation routines are going to handle it specially.
1374 Don't change the value. */
1375 resolved
= symbol_resolved_p (add_symbol
);
1379 /* Don't leave symbol loops. */
1381 && !add_symbol
->flags
.local_symbol
1382 && add_symbol
->flags
.resolving
)
1385 if (finalize_syms
&& final_val
== 0)
1387 if (add_symbol
->flags
.local_symbol
)
1388 add_symbol
= local_symbol_convert (add_symbol
);
1389 copy_symbol_attributes (symp
, add_symbol
);
1392 /* If we have equated this symbol to an undefined or common
1393 symbol, keep X_op set to O_symbol, and don't change
1394 X_add_number. This permits the routine which writes out
1395 relocation to detect this case, and convert the
1396 relocation to be against the symbol to which this symbol
1398 if (seg_left
== undefined_section
1399 || bfd_is_com_section (seg_left
)
1400 #if defined (OBJ_COFF) && defined (TE_PE)
1401 || S_IS_WEAK (add_symbol
)
1404 && ((final_seg
== expr_section
1405 && seg_left
!= expr_section
1406 && seg_left
!= absolute_section
)
1407 || symbol_shadow_p (symp
))))
1411 symp
->x
->value
.X_op
= O_symbol
;
1412 symp
->x
->value
.X_add_symbol
= add_symbol
;
1413 symp
->x
->value
.X_add_number
= final_val
;
1414 /* Use X_op_symbol as a flag. */
1415 symp
->x
->value
.X_op_symbol
= add_symbol
;
1417 final_seg
= seg_left
;
1418 final_val
+= symp
->frag
->fr_address
+ left
;
1419 resolved
= symbol_resolved_p (add_symbol
);
1420 symp
->flags
.resolving
= 0;
1421 goto exit_dont_set_value
;
1425 final_val
+= symp
->frag
->fr_address
+ left
;
1426 if (final_seg
== expr_section
|| final_seg
== undefined_section
)
1427 final_seg
= seg_left
;
1430 resolved
= symbol_resolved_p (add_symbol
);
1431 if (S_IS_WEAKREFR (symp
))
1433 symp
->flags
.resolving
= 0;
1434 goto exit_dont_set_value
;
1441 left
= resolve_symbol_value (add_symbol
);
1442 seg_left
= S_GET_SEGMENT (add_symbol
);
1444 /* By reducing these to the relevant dyadic operator, we get
1445 !S -> S == 0 permitted on anything,
1446 -S -> 0 - S only permitted on absolute
1447 ~S -> S ^ ~0 only permitted on absolute */
1448 if (op
!= O_logical_not
&& seg_left
!= absolute_section
1450 report_op_error (symp
, NULL
, op
, add_symbol
);
1452 if (final_seg
== expr_section
|| final_seg
== undefined_section
)
1453 final_seg
= absolute_section
;
1457 else if (op
== O_logical_not
)
1462 final_val
+= left
+ symp
->frag
->fr_address
;
1464 resolved
= symbol_resolved_p (add_symbol
);
1472 case O_bit_inclusive_or
:
1474 case O_bit_exclusive_or
:
1486 left
= resolve_symbol_value (add_symbol
);
1487 right
= resolve_symbol_value (op_symbol
);
1488 seg_left
= S_GET_SEGMENT (add_symbol
);
1489 seg_right
= S_GET_SEGMENT (op_symbol
);
1491 /* Simplify addition or subtraction of a constant by folding the
1492 constant into X_add_number. */
1495 if (seg_right
== absolute_section
)
1500 else if (seg_left
== absolute_section
)
1503 add_symbol
= op_symbol
;
1505 seg_left
= seg_right
;
1509 else if (op
== O_subtract
)
1511 if (seg_right
== absolute_section
)
1519 /* Equality and non-equality tests are permitted on anything.
1520 Subtraction, and other comparison operators are permitted if
1521 both operands are in the same section. Otherwise, both
1522 operands must be absolute. We already handled the case of
1523 addition or subtraction of a constant above. This will
1524 probably need to be changed for an object file format which
1525 supports arbitrary expressions. */
1526 if (!(seg_left
== absolute_section
1527 && seg_right
== absolute_section
)
1528 && !(op
== O_eq
|| op
== O_ne
)
1529 && !((op
== O_subtract
1530 || op
== O_lt
|| op
== O_le
|| op
== O_ge
|| op
== O_gt
)
1531 && seg_left
== seg_right
1532 && (seg_left
!= undefined_section
1533 || add_symbol
== op_symbol
)))
1535 /* Don't emit messages unless we're finalizing the symbol value,
1536 otherwise we may get the same message multiple times. */
1538 report_op_error (symp
, add_symbol
, op
, op_symbol
);
1539 /* However do not move the symbol into the absolute section
1540 if it cannot currently be resolved - this would confuse
1541 other parts of the assembler into believing that the
1542 expression had been evaluated to zero. */
1548 && (final_seg
== expr_section
|| final_seg
== undefined_section
))
1549 final_seg
= absolute_section
;
1551 /* Check for division by zero. */
1552 if ((op
== O_divide
|| op
== O_modulus
) && right
== 0)
1554 /* If seg_right is not absolute_section, then we've
1555 already issued a warning about using a bad symbol. */
1556 if (seg_right
== absolute_section
&& finalize_syms
)
1561 if (expr_symbol_where (symp
, &file
, &line
))
1562 as_bad_where (file
, line
, _("division by zero"));
1564 as_bad (_("division by zero when setting `%s'"),
1570 if ((op
== O_left_shift
|| op
== O_right_shift
)
1571 && (valueT
) right
>= sizeof (valueT
) * CHAR_BIT
)
1573 as_warn_value_out_of_range (_("shift count"), right
, 0,
1574 sizeof (valueT
) * CHAR_BIT
- 1,
1579 switch (symp
->x
->value
.X_op
)
1581 case O_multiply
: left
*= right
; break;
1582 case O_divide
: left
/= right
; break;
1583 case O_modulus
: left
%= right
; break;
1585 left
= (valueT
) left
<< (valueT
) right
; break;
1587 left
= (valueT
) left
>> (valueT
) right
; break;
1588 case O_bit_inclusive_or
: left
|= right
; break;
1589 case O_bit_or_not
: left
|= ~right
; break;
1590 case O_bit_exclusive_or
: left
^= right
; break;
1591 case O_bit_and
: left
&= right
; break;
1592 case O_add
: left
+= right
; break;
1593 case O_subtract
: left
-= right
; break;
1596 left
= (left
== right
&& seg_left
== seg_right
1597 && (seg_left
!= undefined_section
1598 || add_symbol
== op_symbol
)
1599 ? ~ (offsetT
) 0 : 0);
1600 if (symp
->x
->value
.X_op
== O_ne
)
1603 case O_lt
: left
= left
< right
? ~ (offsetT
) 0 : 0; break;
1604 case O_le
: left
= left
<= right
? ~ (offsetT
) 0 : 0; break;
1605 case O_ge
: left
= left
>= right
? ~ (offsetT
) 0 : 0; break;
1606 case O_gt
: left
= left
> right
? ~ (offsetT
) 0 : 0; break;
1607 case O_logical_and
: left
= left
&& right
; break;
1608 case O_logical_or
: left
= left
|| right
; break;
1613 /* See PR 20895 for a reproducer. */
1614 as_bad (_("Invalid operation on symbol"));
1615 goto exit_dont_set_value
;
1621 final_val
+= symp
->frag
->fr_address
+ left
;
1622 if (final_seg
== expr_section
|| final_seg
== undefined_section
)
1624 if (seg_left
== undefined_section
1625 || seg_right
== undefined_section
)
1626 final_seg
= undefined_section
;
1627 else if (seg_left
== absolute_section
)
1628 final_seg
= seg_right
;
1630 final_seg
= seg_left
;
1632 resolved
= (symbol_resolved_p (add_symbol
)
1633 && symbol_resolved_p (op_symbol
));
1638 /* Give an error (below) if not in expr_section. We don't
1639 want to worry about expr_section symbols, because they
1640 are fictional (they are created as part of expression
1641 resolution), and any problems may not actually mean
1646 symp
->flags
.resolving
= 0;
1650 S_SET_VALUE (symp
, final_val
);
1652 exit_dont_set_value
:
1653 /* Always set the segment, even if not finalizing the value.
1654 The segment is used to determine whether a symbol is defined. */
1655 S_SET_SEGMENT (symp
, final_seg
);
1657 /* Don't worry if we can't resolve an expr_section symbol. */
1661 symp
->flags
.resolved
= 1;
1662 else if (S_GET_SEGMENT (symp
) != expr_section
)
1664 as_bad (_("can't resolve value for symbol `%s'"),
1666 symp
->flags
.resolved
= 1;
1673 /* A static function passed to hash_traverse. */
1676 resolve_local_symbol (void **slot
, void *arg ATTRIBUTE_UNUSED
)
1678 symbol_entry_t
*entry
= *((symbol_entry_t
**) slot
);
1679 if (entry
->sy
.flags
.local_symbol
)
1680 resolve_symbol_value (&entry
->sy
);
1685 /* Resolve all local symbols. */
1688 resolve_local_symbol_values (void)
1690 htab_traverse (sy_hash
, resolve_local_symbol
, NULL
);
1693 /* Obtain the current value of a symbol without changing any
1694 sub-expressions used. */
1697 snapshot_symbol (symbolS
**symbolPP
, valueT
*valueP
, segT
*segP
, fragS
**fragPP
)
1699 symbolS
*symbolP
= *symbolPP
;
1701 if (symbolP
->flags
.local_symbol
)
1703 struct local_symbol
*locsym
= (struct local_symbol
*) symbolP
;
1705 *valueP
= locsym
->value
;
1706 *segP
= locsym
->section
;
1707 *fragPP
= locsym
->frag
;
1711 expressionS exp
= symbolP
->x
->value
;
1713 if (!symbolP
->flags
.resolved
&& exp
.X_op
!= O_illegal
)
1717 if (symbolP
->flags
.resolving
)
1719 symbolP
->flags
.resolving
= 1;
1720 resolved
= resolve_expression (&exp
);
1721 symbolP
->flags
.resolving
= 0;
1729 if (!symbol_equated_p (symbolP
))
1734 symbolP
= exp
.X_add_symbol
;
1741 *symbolPP
= symbolP
;
1743 /* A bogus input file can result in resolve_expression()
1744 generating a local symbol, so we have to check again. */
1745 if (symbolP
->flags
.local_symbol
)
1747 struct local_symbol
*locsym
= (struct local_symbol
*) symbolP
;
1749 *valueP
= locsym
->value
;
1750 *segP
= locsym
->section
;
1751 *fragPP
= locsym
->frag
;
1755 *valueP
= exp
.X_add_number
;
1756 *segP
= symbolP
->bsym
->section
;
1757 *fragPP
= symbolP
->frag
;
1760 if (*segP
== expr_section
)
1763 case O_constant
: *segP
= absolute_section
; break;
1764 case O_register
: *segP
= reg_section
; break;
1772 /* Dollar labels look like a number followed by a dollar sign. Eg, "42$".
1773 They are *really* local. That is, they go out of scope whenever we see a
1774 label that isn't local. Also, like fb labels, there can be multiple
1775 instances of a dollar label. Therefor, we name encode each instance with
1776 the instance number, keep a list of defined symbols separate from the real
1777 symbol table, and we treat these buggers as a sparse array. */
1779 static long *dollar_labels
;
1780 static long *dollar_label_instances
;
1781 static char *dollar_label_defines
;
1782 static size_t dollar_label_count
;
1783 static size_t dollar_label_max
;
1786 dollar_label_defined (long label
)
1790 know ((dollar_labels
!= NULL
) || (dollar_label_count
== 0));
1792 for (i
= dollar_labels
; i
< dollar_labels
+ dollar_label_count
; ++i
)
1794 return dollar_label_defines
[i
- dollar_labels
];
1796 /* If we get here, label isn't defined. */
1801 dollar_label_instance (long label
)
1805 know ((dollar_labels
!= NULL
) || (dollar_label_count
== 0));
1807 for (i
= dollar_labels
; i
< dollar_labels
+ dollar_label_count
; ++i
)
1809 return (dollar_label_instances
[i
- dollar_labels
]);
1811 /* If we get here, we haven't seen the label before.
1812 Therefore its instance count is zero. */
1817 dollar_label_clear (void)
1819 if (dollar_label_count
)
1820 memset (dollar_label_defines
, '\0', dollar_label_count
);
1823 #define DOLLAR_LABEL_BUMP_BY 10
1826 define_dollar_label (long label
)
1830 for (i
= dollar_labels
; i
< dollar_labels
+ dollar_label_count
; ++i
)
1833 ++dollar_label_instances
[i
- dollar_labels
];
1834 dollar_label_defines
[i
- dollar_labels
] = 1;
1838 /* If we get to here, we don't have label listed yet. */
1840 if (dollar_labels
== NULL
)
1842 dollar_labels
= XNEWVEC (long, DOLLAR_LABEL_BUMP_BY
);
1843 dollar_label_instances
= XNEWVEC (long, DOLLAR_LABEL_BUMP_BY
);
1844 dollar_label_defines
= XNEWVEC (char, DOLLAR_LABEL_BUMP_BY
);
1845 dollar_label_max
= DOLLAR_LABEL_BUMP_BY
;
1846 dollar_label_count
= 0;
1848 else if (dollar_label_count
== dollar_label_max
)
1850 dollar_label_max
+= DOLLAR_LABEL_BUMP_BY
;
1851 dollar_labels
= XRESIZEVEC (long, dollar_labels
, dollar_label_max
);
1852 dollar_label_instances
= XRESIZEVEC (long, dollar_label_instances
,
1854 dollar_label_defines
= XRESIZEVEC (char, dollar_label_defines
,
1856 } /* if we needed to grow */
1858 dollar_labels
[dollar_label_count
] = label
;
1859 dollar_label_instances
[dollar_label_count
] = 1;
1860 dollar_label_defines
[dollar_label_count
] = 1;
1861 ++dollar_label_count
;
1864 /* Caller must copy returned name: we re-use the area for the next name.
1866 The mth occurrence of label n: is turned into the symbol "Ln^Am"
1867 where n is the label number and m is the instance number. "L" makes
1868 it a label discarded unless debugging and "^A"('\1') ensures no
1869 ordinary symbol SHOULD get the same name as a local label
1870 symbol. The first "4:" is "L4^A1" - the m numbers begin at 1.
1872 fb labels get the same treatment, except that ^B is used in place
1875 char * /* Return local label name. */
1876 dollar_label_name (long n
, /* we just saw "n$:" : n a number. */
1877 int augend
/* 0 for current instance, 1 for new instance. */)
1880 /* Returned to caller, then copied. Used for created names ("4f"). */
1881 static char symbol_name_build
[24];
1884 char symbol_name_temporary
[20]; /* Build up a number, BACKWARDS. */
1887 know (augend
== 0 || augend
== 1);
1888 p
= symbol_name_build
;
1889 #ifdef LOCAL_LABEL_PREFIX
1890 *p
++ = LOCAL_LABEL_PREFIX
;
1894 /* Next code just does sprintf( {}, "%d", n); */
1896 q
= symbol_name_temporary
;
1897 for (*q
++ = 0, i
= n
; i
; ++q
)
1902 while ((*p
= *--q
) != '\0')
1905 *p
++ = DOLLAR_LABEL_CHAR
; /* ^A */
1907 /* Instance number. */
1908 q
= symbol_name_temporary
;
1909 for (*q
++ = 0, i
= dollar_label_instance (n
) + augend
; i
; ++q
)
1914 while ((*p
++ = *--q
) != '\0');
1916 /* The label, as a '\0' ended string, starts at symbol_name_build. */
1917 return symbol_name_build
;
1920 /* Somebody else's idea of local labels. They are made by "n:" where n
1921 is any decimal digit. Refer to them with
1922 "nb" for previous (backward) n:
1923 or "nf" for next (forward) n:.
1925 We do a little better and let n be any number, not just a single digit, but
1926 since the other guy's assembler only does ten, we treat the first ten
1929 Like someone else's assembler, we have one set of local label counters for
1930 entire assembly, not one set per (sub)segment like in most assemblers. This
1931 implies that one can refer to a label in another segment, and indeed some
1932 crufty compilers have done just that.
1934 Since there could be a LOT of these things, treat them as a sparse
1937 #define FB_LABEL_SPECIAL (10)
1939 static long fb_low_counter
[FB_LABEL_SPECIAL
];
1940 static long *fb_labels
;
1941 static long *fb_label_instances
;
1942 static long fb_label_count
;
1943 static long fb_label_max
;
1945 /* This must be more than FB_LABEL_SPECIAL. */
1946 #define FB_LABEL_BUMP_BY (FB_LABEL_SPECIAL + 6)
1949 fb_label_init (void)
1951 memset ((void *) fb_low_counter
, '\0', sizeof (fb_low_counter
));
1954 /* Add one to the instance number of this fb label. */
1957 fb_label_instance_inc (long label
)
1961 if ((unsigned long) label
< FB_LABEL_SPECIAL
)
1963 ++fb_low_counter
[label
];
1967 if (fb_labels
!= NULL
)
1969 for (i
= fb_labels
+ FB_LABEL_SPECIAL
;
1970 i
< fb_labels
+ fb_label_count
; ++i
)
1974 ++fb_label_instances
[i
- fb_labels
];
1976 } /* if we find it */
1977 } /* for each existing label */
1980 /* If we get to here, we don't have label listed yet. */
1982 if (fb_labels
== NULL
)
1984 fb_labels
= XNEWVEC (long, FB_LABEL_BUMP_BY
);
1985 fb_label_instances
= XNEWVEC (long, FB_LABEL_BUMP_BY
);
1986 fb_label_max
= FB_LABEL_BUMP_BY
;
1987 fb_label_count
= FB_LABEL_SPECIAL
;
1990 else if (fb_label_count
== fb_label_max
)
1992 fb_label_max
+= FB_LABEL_BUMP_BY
;
1993 fb_labels
= XRESIZEVEC (long, fb_labels
, fb_label_max
);
1994 fb_label_instances
= XRESIZEVEC (long, fb_label_instances
, fb_label_max
);
1995 } /* if we needed to grow */
1997 fb_labels
[fb_label_count
] = label
;
1998 fb_label_instances
[fb_label_count
] = 1;
2003 fb_label_instance (long label
)
2007 if ((unsigned long) label
< FB_LABEL_SPECIAL
)
2009 return (fb_low_counter
[label
]);
2012 if (fb_labels
!= NULL
)
2014 for (i
= fb_labels
+ FB_LABEL_SPECIAL
;
2015 i
< fb_labels
+ fb_label_count
; ++i
)
2019 return (fb_label_instances
[i
- fb_labels
]);
2020 } /* if we find it */
2021 } /* for each existing label */
2024 /* We didn't find the label, so this must be a reference to the
2029 /* Caller must copy returned name: we re-use the area for the next name.
2031 The mth occurrence of label n: is turned into the symbol "Ln^Bm"
2032 where n is the label number and m is the instance number. "L" makes
2033 it a label discarded unless debugging and "^B"('\2') ensures no
2034 ordinary symbol SHOULD get the same name as a local label
2035 symbol. The first "4:" is "L4^B1" - the m numbers begin at 1.
2037 dollar labels get the same treatment, except that ^A is used in
2040 char * /* Return local label name. */
2041 fb_label_name (long n
, /* We just saw "n:", "nf" or "nb" : n a number. */
2042 long augend
/* 0 for nb, 1 for n:, nf. */)
2045 /* Returned to caller, then copied. Used for created names ("4f"). */
2046 static char symbol_name_build
[24];
2049 char symbol_name_temporary
[20]; /* Build up a number, BACKWARDS. */
2053 know ((unsigned long) augend
<= 2 /* See mmix_fb_label. */);
2055 know ((unsigned long) augend
<= 1);
2057 p
= symbol_name_build
;
2058 #ifdef LOCAL_LABEL_PREFIX
2059 *p
++ = LOCAL_LABEL_PREFIX
;
2063 /* Next code just does sprintf( {}, "%d", n); */
2065 q
= symbol_name_temporary
;
2066 for (*q
++ = 0, i
= n
; i
; ++q
)
2071 while ((*p
= *--q
) != '\0')
2074 *p
++ = LOCAL_LABEL_CHAR
; /* ^B */
2076 /* Instance number. */
2077 q
= symbol_name_temporary
;
2078 for (*q
++ = 0, i
= fb_label_instance (n
) + augend
; i
; ++q
)
2083 while ((*p
++ = *--q
) != '\0');
2085 /* The label, as a '\0' ended string, starts at symbol_name_build. */
2086 return (symbol_name_build
);
2089 /* Decode name that may have been generated by foo_label_name() above.
2090 If the name wasn't generated by foo_label_name(), then return it
2091 unaltered. This is used for error messages. */
2094 decode_local_label_name (char *s
)
2097 char *symbol_decode
;
2099 int instance_number
;
2101 const char *message_format
;
2104 #ifdef LOCAL_LABEL_PREFIX
2105 if (s
[lindex
] == LOCAL_LABEL_PREFIX
)
2109 if (s
[lindex
] != 'L')
2112 for (label_number
= 0, p
= s
+ lindex
+ 1; ISDIGIT (*p
); ++p
)
2113 label_number
= (10 * label_number
) + *p
- '0';
2115 if (*p
== DOLLAR_LABEL_CHAR
)
2117 else if (*p
== LOCAL_LABEL_CHAR
)
2122 for (instance_number
= 0, p
++; ISDIGIT (*p
); ++p
)
2123 instance_number
= (10 * instance_number
) + *p
- '0';
2125 message_format
= _("\"%d\" (instance number %d of a %s label)");
2126 symbol_decode
= (char *) obstack_alloc (¬es
, strlen (message_format
) + 30);
2127 sprintf (symbol_decode
, message_format
, label_number
, instance_number
, type
);
2129 return symbol_decode
;
2132 /* Get the value of a symbol. */
2135 S_GET_VALUE (symbolS
*s
)
2137 if (s
->flags
.local_symbol
)
2138 return resolve_symbol_value (s
);
2140 if (!s
->flags
.resolved
)
2142 valueT val
= resolve_symbol_value (s
);
2146 if (S_IS_WEAKREFR (s
))
2147 return S_GET_VALUE (s
->x
->value
.X_add_symbol
);
2149 if (s
->x
->value
.X_op
!= O_constant
)
2151 if (! s
->flags
.resolved
2152 || s
->x
->value
.X_op
!= O_symbol
2153 || (S_IS_DEFINED (s
) && ! S_IS_COMMON (s
)))
2154 as_bad (_("attempt to get value of unresolved symbol `%s'"),
2157 return (valueT
) s
->x
->value
.X_add_number
;
2160 /* Set the value of a symbol. */
2163 S_SET_VALUE (symbolS
*s
, valueT val
)
2165 if (s
->flags
.local_symbol
)
2167 ((struct local_symbol
*) s
)->value
= val
;
2171 s
->x
->value
.X_op
= O_constant
;
2172 s
->x
->value
.X_add_number
= (offsetT
) val
;
2173 s
->x
->value
.X_unsigned
= 0;
2174 S_CLEAR_WEAKREFR (s
);
2178 copy_symbol_attributes (symbolS
*dest
, symbolS
*src
)
2180 if (dest
->flags
.local_symbol
)
2181 dest
= local_symbol_convert (dest
);
2182 if (src
->flags
.local_symbol
)
2183 src
= local_symbol_convert (src
);
2185 /* In an expression, transfer the settings of these flags.
2186 The user can override later, of course. */
2187 #define COPIED_SYMFLAGS (BSF_FUNCTION | BSF_OBJECT \
2188 | BSF_GNU_INDIRECT_FUNCTION)
2189 dest
->bsym
->flags
|= src
->bsym
->flags
& COPIED_SYMFLAGS
;
2191 #ifdef OBJ_COPY_SYMBOL_ATTRIBUTES
2192 OBJ_COPY_SYMBOL_ATTRIBUTES (dest
, src
);
2195 #ifdef TC_COPY_SYMBOL_ATTRIBUTES
2196 TC_COPY_SYMBOL_ATTRIBUTES (dest
, src
);
2201 S_IS_FUNCTION (symbolS
*s
)
2205 if (s
->flags
.local_symbol
)
2208 flags
= s
->bsym
->flags
;
2210 return (flags
& BSF_FUNCTION
) != 0;
2214 S_IS_EXTERNAL (symbolS
*s
)
2218 if (s
->flags
.local_symbol
)
2221 flags
= s
->bsym
->flags
;
2224 if ((flags
& BSF_LOCAL
) && (flags
& BSF_GLOBAL
))
2227 return (flags
& BSF_GLOBAL
) != 0;
2231 S_IS_WEAK (symbolS
*s
)
2233 if (s
->flags
.local_symbol
)
2235 /* Conceptually, a weakrefr is weak if the referenced symbol is. We
2236 could probably handle a WEAKREFR as always weak though. E.g., if
2237 the referenced symbol has lost its weak status, there's no reason
2238 to keep handling the weakrefr as if it was weak. */
2239 if (S_IS_WEAKREFR (s
))
2240 return S_IS_WEAK (s
->x
->value
.X_add_symbol
);
2241 return (s
->bsym
->flags
& BSF_WEAK
) != 0;
2245 S_IS_WEAKREFR (symbolS
*s
)
2247 if (s
->flags
.local_symbol
)
2249 return s
->flags
.weakrefr
!= 0;
2253 S_IS_WEAKREFD (symbolS
*s
)
2255 if (s
->flags
.local_symbol
)
2257 return s
->flags
.weakrefd
!= 0;
2261 S_IS_COMMON (symbolS
*s
)
2263 if (s
->flags
.local_symbol
)
2265 return bfd_is_com_section (s
->bsym
->section
);
2269 S_IS_DEFINED (symbolS
*s
)
2271 if (s
->flags
.local_symbol
)
2272 return ((struct local_symbol
*) s
)->section
!= undefined_section
;
2273 return s
->bsym
->section
!= undefined_section
;
2277 #ifndef EXTERN_FORCE_RELOC
2278 #define EXTERN_FORCE_RELOC IS_ELF
2281 /* Return true for symbols that should not be reduced to section
2282 symbols or eliminated from expressions, because they may be
2283 overridden by the linker. */
2285 S_FORCE_RELOC (symbolS
*s
, int strict
)
2288 if (s
->flags
.local_symbol
)
2289 sec
= ((struct local_symbol
*) s
)->section
;
2293 && ((s
->bsym
->flags
& BSF_WEAK
) != 0
2294 || (EXTERN_FORCE_RELOC
2295 && (s
->bsym
->flags
& BSF_GLOBAL
) != 0)))
2296 || (s
->bsym
->flags
& BSF_GNU_INDIRECT_FUNCTION
) != 0)
2298 sec
= s
->bsym
->section
;
2300 return bfd_is_und_section (sec
) || bfd_is_com_section (sec
);
2304 S_IS_DEBUG (symbolS
*s
)
2306 if (s
->flags
.local_symbol
)
2308 if (s
->bsym
->flags
& BSF_DEBUGGING
)
2314 S_IS_LOCAL (symbolS
*s
)
2319 if (s
->flags
.local_symbol
)
2322 flags
= s
->bsym
->flags
;
2325 if ((flags
& BSF_LOCAL
) && (flags
& BSF_GLOBAL
))
2328 if (bfd_asymbol_section (s
->bsym
) == reg_section
)
2331 if (flag_strip_local_absolute
2332 /* Keep BSF_FILE symbols in order to allow debuggers to identify
2333 the source file even when the object file is stripped. */
2334 && (flags
& (BSF_GLOBAL
| BSF_FILE
)) == 0
2335 && bfd_asymbol_section (s
->bsym
) == absolute_section
)
2338 name
= S_GET_NAME (s
);
2339 return (name
!= NULL
2341 && (strchr (name
, DOLLAR_LABEL_CHAR
)
2342 || strchr (name
, LOCAL_LABEL_CHAR
)
2343 #if FAKE_LABEL_CHAR != DOLLAR_LABEL_CHAR
2344 || strchr (name
, FAKE_LABEL_CHAR
)
2346 || TC_LABEL_IS_LOCAL (name
)
2347 || (! flag_keep_locals
2348 && (bfd_is_local_label (stdoutput
, s
->bsym
)
2351 && name
[1] == '?')))));
2355 S_IS_STABD (symbolS
*s
)
2357 return S_GET_NAME (s
) == 0;
2361 S_CAN_BE_REDEFINED (const symbolS
*s
)
2363 if (s
->flags
.local_symbol
)
2364 return (((struct local_symbol
*) s
)->frag
2365 == &predefined_address_frag
);
2366 /* Permit register names to be redefined. */
2367 return s
->bsym
->section
== reg_section
;
2371 S_IS_VOLATILE (const symbolS
*s
)
2373 if (s
->flags
.local_symbol
)
2375 return s
->flags
.volatil
;
2379 S_IS_FORWARD_REF (const symbolS
*s
)
2381 if (s
->flags
.local_symbol
)
2383 return s
->flags
.forward_ref
;
2387 S_GET_NAME (symbolS
*s
)
2393 S_GET_SEGMENT (symbolS
*s
)
2395 if (s
->flags
.local_symbol
)
2396 return ((struct local_symbol
*) s
)->section
;
2397 return s
->bsym
->section
;
2401 S_SET_SEGMENT (symbolS
*s
, segT seg
)
2403 if (s
->flags
.local_symbol
)
2405 ((struct local_symbol
*) s
)->section
= seg
;
2409 /* Don't reassign section symbols. The direct reason is to prevent seg
2410 faults assigning back to const global symbols such as *ABS*, but it
2411 shouldn't happen anyway. */
2412 if (s
->bsym
->flags
& BSF_SECTION_SYM
)
2414 if (s
->bsym
->section
!= seg
)
2418 s
->bsym
->section
= seg
;
2422 S_SET_EXTERNAL (symbolS
*s
)
2424 if (s
->flags
.local_symbol
)
2425 s
= local_symbol_convert (s
);
2426 if ((s
->bsym
->flags
& BSF_WEAK
) != 0)
2428 /* Let .weak override .global. */
2431 if (s
->bsym
->flags
& BSF_SECTION_SYM
)
2433 /* Do not reassign section symbols. */
2434 as_warn (_("section symbols are already global"));
2437 #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
2438 if (S_GET_SEGMENT (s
) == reg_section
)
2440 as_bad ("can't make register symbol `%s' global",
2445 s
->bsym
->flags
|= BSF_GLOBAL
;
2446 s
->bsym
->flags
&= ~(BSF_LOCAL
| BSF_WEAK
);
2449 if (! an_external_name
&& S_GET_NAME(s
)[0] != '.')
2450 an_external_name
= S_GET_NAME (s
);
2455 S_CLEAR_EXTERNAL (symbolS
*s
)
2457 if (s
->flags
.local_symbol
)
2459 if ((s
->bsym
->flags
& BSF_WEAK
) != 0)
2461 /* Let .weak override. */
2464 s
->bsym
->flags
|= BSF_LOCAL
;
2465 s
->bsym
->flags
&= ~(BSF_GLOBAL
| BSF_WEAK
);
2469 S_SET_WEAK (symbolS
*s
)
2471 if (s
->flags
.local_symbol
)
2472 s
= local_symbol_convert (s
);
2473 #ifdef obj_set_weak_hook
2474 obj_set_weak_hook (s
);
2476 s
->bsym
->flags
|= BSF_WEAK
;
2477 s
->bsym
->flags
&= ~(BSF_GLOBAL
| BSF_LOCAL
);
2481 S_SET_WEAKREFR (symbolS
*s
)
2483 if (s
->flags
.local_symbol
)
2484 s
= local_symbol_convert (s
);
2485 s
->flags
.weakrefr
= 1;
2486 /* If the alias was already used, make sure we mark the target as
2487 used as well, otherwise it might be dropped from the symbol
2488 table. This may have unintended side effects if the alias is
2489 later redirected to another symbol, such as keeping the unused
2490 previous target in the symbol table. Since it will be weak, it's
2493 symbol_mark_used (s
->x
->value
.X_add_symbol
);
2497 S_CLEAR_WEAKREFR (symbolS
*s
)
2499 if (s
->flags
.local_symbol
)
2501 s
->flags
.weakrefr
= 0;
2505 S_SET_WEAKREFD (symbolS
*s
)
2507 if (s
->flags
.local_symbol
)
2508 s
= local_symbol_convert (s
);
2509 s
->flags
.weakrefd
= 1;
2514 S_CLEAR_WEAKREFD (symbolS
*s
)
2516 if (s
->flags
.local_symbol
)
2518 if (s
->flags
.weakrefd
)
2520 s
->flags
.weakrefd
= 0;
2521 /* If a weakref target symbol is weak, then it was never
2522 referenced directly before, not even in a .global directive,
2523 so decay it to local. If it remains undefined, it will be
2524 later turned into a global, like any other undefined
2526 if (s
->bsym
->flags
& BSF_WEAK
)
2528 #ifdef obj_clear_weak_hook
2529 obj_clear_weak_hook (s
);
2531 s
->bsym
->flags
&= ~BSF_WEAK
;
2532 s
->bsym
->flags
|= BSF_LOCAL
;
2538 S_SET_THREAD_LOCAL (symbolS
*s
)
2540 if (s
->flags
.local_symbol
)
2541 s
= local_symbol_convert (s
);
2542 if (bfd_is_com_section (s
->bsym
->section
)
2543 && (s
->bsym
->flags
& BSF_THREAD_LOCAL
) != 0)
2545 s
->bsym
->flags
|= BSF_THREAD_LOCAL
;
2546 if ((s
->bsym
->flags
& BSF_FUNCTION
) != 0)
2547 as_bad (_("Accessing function `%s' as thread-local object"),
2549 else if (! bfd_is_und_section (s
->bsym
->section
)
2550 && (s
->bsym
->section
->flags
& SEC_THREAD_LOCAL
) == 0)
2551 as_bad (_("Accessing `%s' as thread-local object"),
2556 S_SET_NAME (symbolS
*s
, const char *name
)
2559 if (s
->flags
.local_symbol
)
2561 s
->bsym
->name
= name
;
2565 S_SET_VOLATILE (symbolS
*s
)
2567 if (s
->flags
.local_symbol
)
2568 s
= local_symbol_convert (s
);
2569 s
->flags
.volatil
= 1;
2573 S_CLEAR_VOLATILE (symbolS
*s
)
2575 if (!s
->flags
.local_symbol
)
2576 s
->flags
.volatil
= 0;
2580 S_SET_FORWARD_REF (symbolS
*s
)
2582 if (s
->flags
.local_symbol
)
2583 s
= local_symbol_convert (s
);
2584 s
->flags
.forward_ref
= 1;
2587 /* Return the previous symbol in a chain. */
2590 symbol_previous (symbolS
*s
)
2592 if (s
->flags
.local_symbol
)
2594 return s
->x
->previous
;
2597 /* Return the next symbol in a chain. */
2600 symbol_next (symbolS
*s
)
2602 if (s
->flags
.local_symbol
)
2607 /* Return a pointer to the value of a symbol as an expression. */
2610 symbol_get_value_expression (symbolS
*s
)
2612 if (s
->flags
.local_symbol
)
2613 s
= local_symbol_convert (s
);
2614 return &s
->x
->value
;
2617 /* Set the value of a symbol to an expression. */
2620 symbol_set_value_expression (symbolS
*s
, const expressionS
*exp
)
2622 if (s
->flags
.local_symbol
)
2623 s
= local_symbol_convert (s
);
2625 S_CLEAR_WEAKREFR (s
);
2628 /* Return whether 2 symbols are the same. */
2631 symbol_same_p (symbolS
*s1
, symbolS
*s2
)
2636 /* Return a pointer to the X_add_number component of a symbol. */
2639 symbol_X_add_number (symbolS
*s
)
2641 if (s
->flags
.local_symbol
)
2642 return (offsetT
*) &((struct local_symbol
*) s
)->value
;
2644 return &s
->x
->value
.X_add_number
;
2647 /* Set the value of SYM to the current position in the current segment. */
2650 symbol_set_value_now (symbolS
*sym
)
2652 S_SET_SEGMENT (sym
, now_seg
);
2653 S_SET_VALUE (sym
, frag_now_fix ());
2654 symbol_set_frag (sym
, frag_now
);
2657 /* Set the frag of a symbol. */
2660 symbol_set_frag (symbolS
*s
, fragS
*f
)
2662 if (s
->flags
.local_symbol
)
2664 ((struct local_symbol
*) s
)->frag
= f
;
2668 S_CLEAR_WEAKREFR (s
);
2671 /* Return the frag of a symbol. */
2674 symbol_get_frag (symbolS
*s
)
2676 if (s
->flags
.local_symbol
)
2677 return ((struct local_symbol
*) s
)->frag
;
2681 /* Mark a symbol as having been used. */
2684 symbol_mark_used (symbolS
*s
)
2686 if (s
->flags
.local_symbol
)
2689 if (S_IS_WEAKREFR (s
))
2690 symbol_mark_used (s
->x
->value
.X_add_symbol
);
2693 /* Clear the mark of whether a symbol has been used. */
2696 symbol_clear_used (symbolS
*s
)
2698 if (s
->flags
.local_symbol
)
2699 s
= local_symbol_convert (s
);
2703 /* Return whether a symbol has been used. */
2706 symbol_used_p (symbolS
*s
)
2708 if (s
->flags
.local_symbol
)
2710 return s
->flags
.used
;
2713 /* Mark a symbol as having been used in a reloc. */
2716 symbol_mark_used_in_reloc (symbolS
*s
)
2718 if (s
->flags
.local_symbol
)
2719 s
= local_symbol_convert (s
);
2720 s
->flags
.used_in_reloc
= 1;
2723 /* Clear the mark of whether a symbol has been used in a reloc. */
2726 symbol_clear_used_in_reloc (symbolS
*s
)
2728 if (s
->flags
.local_symbol
)
2730 s
->flags
.used_in_reloc
= 0;
2733 /* Return whether a symbol has been used in a reloc. */
2736 symbol_used_in_reloc_p (symbolS
*s
)
2738 if (s
->flags
.local_symbol
)
2740 return s
->flags
.used_in_reloc
;
2743 /* Mark a symbol as an MRI common symbol. */
2746 symbol_mark_mri_common (symbolS
*s
)
2748 if (s
->flags
.local_symbol
)
2749 s
= local_symbol_convert (s
);
2750 s
->flags
.mri_common
= 1;
2753 /* Clear the mark of whether a symbol is an MRI common symbol. */
2756 symbol_clear_mri_common (symbolS
*s
)
2758 if (s
->flags
.local_symbol
)
2760 s
->flags
.mri_common
= 0;
2763 /* Return whether a symbol is an MRI common symbol. */
2766 symbol_mri_common_p (symbolS
*s
)
2768 if (s
->flags
.local_symbol
)
2770 return s
->flags
.mri_common
;
2773 /* Mark a symbol as having been written. */
2776 symbol_mark_written (symbolS
*s
)
2778 if (s
->flags
.local_symbol
)
2780 s
->flags
.written
= 1;
2783 /* Clear the mark of whether a symbol has been written. */
2786 symbol_clear_written (symbolS
*s
)
2788 if (s
->flags
.local_symbol
)
2790 s
->flags
.written
= 0;
2793 /* Return whether a symbol has been written. */
2796 symbol_written_p (symbolS
*s
)
2798 if (s
->flags
.local_symbol
)
2800 return s
->flags
.written
;
2803 /* Mark a symbol has having been resolved. */
2806 symbol_mark_resolved (symbolS
*s
)
2808 s
->flags
.resolved
= 1;
2811 /* Return whether a symbol has been resolved. */
2814 symbol_resolved_p (symbolS
*s
)
2816 return s
->flags
.resolved
;
2819 /* Return whether a symbol is a section symbol. */
2822 symbol_section_p (symbolS
*s
)
2824 if (s
->flags
.local_symbol
)
2826 return (s
->bsym
->flags
& BSF_SECTION_SYM
) != 0;
2829 /* Return whether a symbol is equated to another symbol. */
2832 symbol_equated_p (symbolS
*s
)
2834 if (s
->flags
.local_symbol
)
2836 return s
->x
->value
.X_op
== O_symbol
;
2839 /* Return whether a symbol is equated to another symbol, and should be
2840 treated specially when writing out relocs. */
2843 symbol_equated_reloc_p (symbolS
*s
)
2845 if (s
->flags
.local_symbol
)
2847 /* X_op_symbol, normally not used for O_symbol, is set by
2848 resolve_symbol_value to flag expression syms that have been
2850 return (s
->x
->value
.X_op
== O_symbol
2851 #if defined (OBJ_COFF) && defined (TE_PE)
2854 && ((s
->flags
.resolved
&& s
->x
->value
.X_op_symbol
!= NULL
)
2855 || ! S_IS_DEFINED (s
)
2856 || S_IS_COMMON (s
)));
2859 /* Return whether a symbol has a constant value. */
2862 symbol_constant_p (symbolS
*s
)
2864 if (s
->flags
.local_symbol
)
2866 return s
->x
->value
.X_op
== O_constant
;
2869 /* Return whether a symbol was cloned and thus removed from the global
2873 symbol_shadow_p (symbolS
*s
)
2875 if (s
->flags
.local_symbol
)
2877 return s
->x
->next
== s
;
2880 /* If S is a struct symbol return S, otherwise return NULL. */
2883 symbol_symbolS (symbolS
*s
)
2885 if (s
->flags
.local_symbol
)
2890 /* Return the BFD symbol for a symbol. */
2893 symbol_get_bfdsym (symbolS
*s
)
2895 if (s
->flags
.local_symbol
)
2896 s
= local_symbol_convert (s
);
2900 /* Set the BFD symbol for a symbol. */
2903 symbol_set_bfdsym (symbolS
*s
, asymbol
*bsym
)
2905 if (s
->flags
.local_symbol
)
2906 s
= local_symbol_convert (s
);
2907 /* Usually, it is harmless to reset a symbol to a BFD section
2908 symbol. For example, obj_elf_change_section sets the BFD symbol
2909 of an old symbol with the newly created section symbol. But when
2910 we have multiple sections with the same name, the newly created
2911 section may have the same name as an old section. We check if the
2912 old symbol has been already marked as a section symbol before
2914 if ((s
->bsym
->flags
& BSF_SECTION_SYM
) == 0)
2916 /* else XXX - What do we do now ? */
2919 #ifdef OBJ_SYMFIELD_TYPE
2921 /* Get a pointer to the object format information for a symbol. */
2924 symbol_get_obj (symbolS
*s
)
2926 if (s
->flags
.local_symbol
)
2927 s
= local_symbol_convert (s
);
2931 /* Set the object format information for a symbol. */
2934 symbol_set_obj (symbolS
*s
, OBJ_SYMFIELD_TYPE
*o
)
2936 if (s
->flags
.local_symbol
)
2937 s
= local_symbol_convert (s
);
2941 #endif /* OBJ_SYMFIELD_TYPE */
2943 #ifdef TC_SYMFIELD_TYPE
2945 /* Get a pointer to the processor information for a symbol. */
2948 symbol_get_tc (symbolS
*s
)
2950 if (s
->flags
.local_symbol
)
2951 s
= local_symbol_convert (s
);
2955 /* Set the processor information for a symbol. */
2958 symbol_set_tc (symbolS
*s
, TC_SYMFIELD_TYPE
*o
)
2960 if (s
->flags
.local_symbol
)
2961 s
= local_symbol_convert (s
);
2965 #endif /* TC_SYMFIELD_TYPE */
2970 symbol_lastP
= NULL
;
2971 symbol_rootP
= NULL
; /* In case we have 0 symbols (!!) */
2972 sy_hash
= htab_create_alloc (16, hash_symbol_entry
, eq_symbol_entry
,
2973 NULL
, xcalloc
, free
);
2975 #if defined (EMIT_SECTION_SYMBOLS) || !defined (RELOC_REQUIRES_SYMBOL)
2976 abs_symbol
.bsym
= bfd_abs_section_ptr
->symbol
;
2978 abs_symbol
.x
= &abs_symbol_x
;
2979 abs_symbol
.x
->value
.X_op
= O_constant
;
2980 abs_symbol
.frag
= &zero_address_frag
;
2982 if (LOCAL_LABELS_FB
)
2987 dot_symbol_init (void)
2989 dot_symbol
.name
= ".";
2990 dot_symbol
.flags
.forward_ref
= 1;
2991 dot_symbol
.bsym
= bfd_make_empty_symbol (stdoutput
);
2992 if (dot_symbol
.bsym
== NULL
)
2993 as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));
2994 dot_symbol
.bsym
->name
= ".";
2995 dot_symbol
.x
= &dot_symbol_x
;
2996 dot_symbol
.x
->value
.X_op
= O_constant
;
3001 /* Maximum indent level.
3002 Available for modification inside a gdb session. */
3003 static int max_indent_level
= 8;
3006 print_symbol_value_1 (FILE *file
, symbolS
*sym
)
3008 const char *name
= S_GET_NAME (sym
);
3009 if (!name
|| !name
[0])
3011 fprintf (file
, "sym ");
3012 fprintf_vma (file
, (bfd_vma
) ((bfd_hostptr_t
) sym
));
3013 fprintf (file
, " %s", name
);
3015 if (sym
->flags
.local_symbol
)
3017 struct local_symbol
*locsym
= (struct local_symbol
*) sym
;
3019 if (locsym
->frag
!= &zero_address_frag
3020 && locsym
->frag
!= NULL
)
3022 fprintf (file
, " frag ");
3023 fprintf_vma (file
, (bfd_vma
) ((bfd_hostptr_t
) locsym
->frag
));
3025 if (locsym
->flags
.resolved
)
3026 fprintf (file
, " resolved");
3027 fprintf (file
, " local");
3031 if (sym
->frag
!= &zero_address_frag
)
3033 fprintf (file
, " frag ");
3034 fprintf_vma (file
, (bfd_vma
) ((bfd_hostptr_t
) sym
->frag
));
3036 if (sym
->flags
.written
)
3037 fprintf (file
, " written");
3038 if (sym
->flags
.resolved
)
3039 fprintf (file
, " resolved");
3040 else if (sym
->flags
.resolving
)
3041 fprintf (file
, " resolving");
3042 if (sym
->flags
.used_in_reloc
)
3043 fprintf (file
, " used-in-reloc");
3044 if (sym
->flags
.used
)
3045 fprintf (file
, " used");
3046 if (S_IS_LOCAL (sym
))
3047 fprintf (file
, " local");
3048 if (S_IS_EXTERNAL (sym
))
3049 fprintf (file
, " extern");
3050 if (S_IS_WEAK (sym
))
3051 fprintf (file
, " weak");
3052 if (S_IS_DEBUG (sym
))
3053 fprintf (file
, " debug");
3054 if (S_IS_DEFINED (sym
))
3055 fprintf (file
, " defined");
3057 if (S_IS_WEAKREFR (sym
))
3058 fprintf (file
, " weakrefr");
3059 if (S_IS_WEAKREFD (sym
))
3060 fprintf (file
, " weakrefd");
3061 fprintf (file
, " %s", segment_name (S_GET_SEGMENT (sym
)));
3062 if (symbol_resolved_p (sym
))
3064 segT s
= S_GET_SEGMENT (sym
);
3066 if (s
!= undefined_section
3067 && s
!= expr_section
)
3068 fprintf (file
, " %lx", (unsigned long) S_GET_VALUE (sym
));
3070 else if (indent_level
< max_indent_level
3071 && S_GET_SEGMENT (sym
) != undefined_section
)
3074 fprintf (file
, "\n%*s<", indent_level
* 4, "");
3075 if (sym
->flags
.local_symbol
)
3076 fprintf (file
, "constant %lx",
3077 (unsigned long) ((struct local_symbol
*) sym
)->value
);
3079 print_expr_1 (file
, &sym
->x
->value
);
3080 fprintf (file
, ">");
3087 print_symbol_value (symbolS
*sym
)
3090 print_symbol_value_1 (stderr
, sym
);
3091 fprintf (stderr
, "\n");
3095 print_binary (FILE *file
, const char *name
, expressionS
*exp
)
3098 fprintf (file
, "%s\n%*s<", name
, indent_level
* 4, "");
3099 print_symbol_value_1 (file
, exp
->X_add_symbol
);
3100 fprintf (file
, ">\n%*s<", indent_level
* 4, "");
3101 print_symbol_value_1 (file
, exp
->X_op_symbol
);
3102 fprintf (file
, ">");
3107 print_expr_1 (FILE *file
, expressionS
*exp
)
3109 fprintf (file
, "expr ");
3110 fprintf_vma (file
, (bfd_vma
) ((bfd_hostptr_t
) exp
));
3111 fprintf (file
, " ");
3115 fprintf (file
, "illegal");
3118 fprintf (file
, "absent");
3121 fprintf (file
, "constant %lx", (unsigned long) exp
->X_add_number
);
3125 fprintf (file
, "symbol\n%*s<", indent_level
* 4, "");
3126 print_symbol_value_1 (file
, exp
->X_add_symbol
);
3127 fprintf (file
, ">");
3129 if (exp
->X_add_number
)
3130 fprintf (file
, "\n%*s%lx", indent_level
* 4, "",
3131 (unsigned long) exp
->X_add_number
);
3135 fprintf (file
, "register #%d", (int) exp
->X_add_number
);
3138 fprintf (file
, "big");
3141 fprintf (file
, "uminus -<");
3143 print_symbol_value_1 (file
, exp
->X_add_symbol
);
3144 fprintf (file
, ">");
3145 goto maybe_print_addnum
;
3147 fprintf (file
, "bit_not");
3150 print_binary (file
, "multiply", exp
);
3153 print_binary (file
, "divide", exp
);
3156 print_binary (file
, "modulus", exp
);
3159 print_binary (file
, "lshift", exp
);
3162 print_binary (file
, "rshift", exp
);
3164 case O_bit_inclusive_or
:
3165 print_binary (file
, "bit_ior", exp
);
3167 case O_bit_exclusive_or
:
3168 print_binary (file
, "bit_xor", exp
);
3171 print_binary (file
, "bit_and", exp
);
3174 print_binary (file
, "eq", exp
);
3177 print_binary (file
, "ne", exp
);
3180 print_binary (file
, "lt", exp
);
3183 print_binary (file
, "le", exp
);
3186 print_binary (file
, "ge", exp
);
3189 print_binary (file
, "gt", exp
);
3192 print_binary (file
, "logical_and", exp
);
3195 print_binary (file
, "logical_or", exp
);
3199 fprintf (file
, "add\n%*s<", indent_level
* 4, "");
3200 print_symbol_value_1 (file
, exp
->X_add_symbol
);
3201 fprintf (file
, ">\n%*s<", indent_level
* 4, "");
3202 print_symbol_value_1 (file
, exp
->X_op_symbol
);
3203 fprintf (file
, ">");
3204 goto maybe_print_addnum
;
3207 fprintf (file
, "subtract\n%*s<", indent_level
* 4, "");
3208 print_symbol_value_1 (file
, exp
->X_add_symbol
);
3209 fprintf (file
, ">\n%*s<", indent_level
* 4, "");
3210 print_symbol_value_1 (file
, exp
->X_op_symbol
);
3211 fprintf (file
, ">");
3212 goto maybe_print_addnum
;
3214 fprintf (file
, "{unknown opcode %d}", (int) exp
->X_op
);
3221 print_expr (expressionS
*exp
)
3223 print_expr_1 (stderr
, exp
);
3224 fprintf (stderr
, "\n");
3228 symbol_print_statistics (FILE *file
)
3230 htab_print_statistics (file
, "symbol table", sy_hash
);
3231 fprintf (file
, "%lu mini local symbols created, %lu converted\n",
3232 local_symbol_count
, local_symbol_conversion_count
);
3235 #ifdef OBJ_COMPLEX_RELC
3237 /* Convert given symbol to a new complex-relocation symbol name. This
3238 may be a recursive function, since it might be called for non-leaf
3239 nodes (plain symbols) in the expression tree. The caller owns the
3240 returning string, so should free it eventually. Errors are
3241 indicated via as_bad and a NULL return value. The given symbol
3242 is marked with used_in_reloc. */
3245 symbol_relc_make_sym (symbolS
* sym
)
3247 char * terminal
= NULL
;
3252 gas_assert (sym
!= NULL
);
3254 /* Recurse to symbol_relc_make_expr if this symbol
3255 is defined as an expression or a plain value. */
3256 if ( S_GET_SEGMENT (sym
) == expr_section
3257 || S_GET_SEGMENT (sym
) == absolute_section
)
3258 return symbol_relc_make_expr (symbol_get_value_expression (sym
));
3260 /* This may be a "fake symbol", referring to ".".
3261 Write out a special null symbol to refer to this position. */
3262 if (! strcmp (S_GET_NAME (sym
), FAKE_LABEL_NAME
))
3263 return xstrdup (".");
3265 /* We hope this is a plain leaf symbol. Construct the encoding
3266 as {S,s}II...:CCCCCCC....
3267 where 'S'/'s' means section symbol / plain symbol
3268 III is decimal for the symbol name length
3269 CCC is the symbol name itself. */
3270 symbol_mark_used_in_reloc (sym
);
3272 sname
= S_GET_NAME (sym
);
3273 sname_len
= strlen (sname
);
3274 typetag
= symbol_section_p (sym
) ? 'S' : 's';
3276 terminal
= XNEWVEC (char, (1 /* S or s */
3277 + 8 /* sname_len in decimal */
3279 + sname_len
/* name itself */
3282 sprintf (terminal
, "%c%d:%s", typetag
, sname_len
, sname
);
3286 /* Convert given value to a new complex-relocation symbol name. This
3287 is a non-recursive function, since it is be called for leaf nodes
3288 (plain values) in the expression tree. The caller owns the
3289 returning string, so should free() it eventually. No errors. */
3292 symbol_relc_make_value (offsetT val
)
3294 char * terminal
= XNEWVEC (char, 28); /* Enough for long long. */
3297 bfd_sprintf_vma (stdoutput
, terminal
+ 1, val
);
3301 /* Convert given expression to a new complex-relocation symbol name.
3302 This is a recursive function, since it traverses the entire given
3303 expression tree. The caller owns the returning string, so should
3304 free() it eventually. Errors are indicated via as_bad() and a NULL
3308 symbol_relc_make_expr (expressionS
* exp
)
3310 const char * opstr
= NULL
; /* Operator prefix string. */
3311 int arity
= 0; /* Arity of this operator. */
3312 char * operands
[3]; /* Up to three operands. */
3313 char * concat_string
= NULL
;
3315 operands
[0] = operands
[1] = operands
[2] = NULL
;
3317 gas_assert (exp
!= NULL
);
3319 /* Match known operators -> fill in opstr, arity, operands[] and fall
3320 through to construct subexpression fragments; may instead return
3321 string directly for leaf nodes. */
3323 /* See expr.h for the meaning of all these enums. Many operators
3324 have an unnatural arity (X_add_number implicitly added). The
3325 conversion logic expands them to explicit "+" subexpressions. */
3330 as_bad ("Unknown expression operator (enum %d)", exp
->X_op
);
3335 return symbol_relc_make_value (exp
->X_add_number
);
3338 if (exp
->X_add_number
)
3342 operands
[0] = symbol_relc_make_sym (exp
->X_add_symbol
);
3343 operands
[1] = symbol_relc_make_value (exp
->X_add_number
);
3347 return symbol_relc_make_sym (exp
->X_add_symbol
);
3349 /* Helper macros for nesting nodes. */
3351 #define HANDLE_XADD_OPT1(str_) \
3352 if (exp->X_add_number) \
3355 opstr = "+:" str_; \
3356 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3357 operands[1] = symbol_relc_make_value (exp->X_add_number); \
3364 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3368 #define HANDLE_XADD_OPT2(str_) \
3369 if (exp->X_add_number) \
3372 opstr = "+:" str_; \
3373 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3374 operands[1] = symbol_relc_make_sym (exp->X_op_symbol); \
3375 operands[2] = symbol_relc_make_value (exp->X_add_number); \
3381 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3382 operands[1] = symbol_relc_make_sym (exp->X_op_symbol); \
3386 /* Nesting nodes. */
3388 case O_uminus
: HANDLE_XADD_OPT1 ("0-");
3389 case O_bit_not
: HANDLE_XADD_OPT1 ("~");
3390 case O_logical_not
: HANDLE_XADD_OPT1 ("!");
3391 case O_multiply
: HANDLE_XADD_OPT2 ("*");
3392 case O_divide
: HANDLE_XADD_OPT2 ("/");
3393 case O_modulus
: HANDLE_XADD_OPT2 ("%");
3394 case O_left_shift
: HANDLE_XADD_OPT2 ("<<");
3395 case O_right_shift
: HANDLE_XADD_OPT2 (">>");
3396 case O_bit_inclusive_or
: HANDLE_XADD_OPT2 ("|");
3397 case O_bit_exclusive_or
: HANDLE_XADD_OPT2 ("^");
3398 case O_bit_and
: HANDLE_XADD_OPT2 ("&");
3399 case O_add
: HANDLE_XADD_OPT2 ("+");
3400 case O_subtract
: HANDLE_XADD_OPT2 ("-");
3401 case O_eq
: HANDLE_XADD_OPT2 ("==");
3402 case O_ne
: HANDLE_XADD_OPT2 ("!=");
3403 case O_lt
: HANDLE_XADD_OPT2 ("<");
3404 case O_le
: HANDLE_XADD_OPT2 ("<=");
3405 case O_ge
: HANDLE_XADD_OPT2 (">=");
3406 case O_gt
: HANDLE_XADD_OPT2 (">");
3407 case O_logical_and
: HANDLE_XADD_OPT2 ("&&");
3408 case O_logical_or
: HANDLE_XADD_OPT2 ("||");
3411 /* Validate & reject early. */
3412 if (arity
>= 1 && ((operands
[0] == NULL
) || (strlen (operands
[0]) == 0)))
3414 if (arity
>= 2 && ((operands
[1] == NULL
) || (strlen (operands
[1]) == 0)))
3416 if (arity
>= 3 && ((operands
[2] == NULL
) || (strlen (operands
[2]) == 0)))
3420 concat_string
= NULL
;
3421 else if (arity
== 0)
3422 concat_string
= xstrdup (opstr
);
3423 else if (arity
== 1)
3424 concat_string
= concat (opstr
, ":", operands
[0], (char *) NULL
);
3425 else if (arity
== 2)
3426 concat_string
= concat (opstr
, ":", operands
[0], ":", operands
[1],
3429 concat_string
= concat (opstr
, ":", operands
[0], ":", operands
[1], ":",
3430 operands
[2], (char *) NULL
);
3432 /* Free operand strings (not opstr). */
3433 if (arity
>= 1) xfree (operands
[0]);
3434 if (arity
>= 2) xfree (operands
[1]);
3435 if (arity
>= 3) xfree (operands
[2]);
3437 return concat_string
;