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 }, hash
, name
, 0, 0, 0 } };
200 return htab_find_with_hash (table
, &needle
, hash
);
204 /* This is non-zero if symbols are case sensitive, which is the
206 int symbols_case_sensitive
= 1;
208 #ifndef WORKING_DOT_WORD
209 extern int new_broken_words
;
212 static htab_t sy_hash
;
214 /* Below are commented in "symbols.h". */
215 symbolS
*symbol_rootP
;
216 symbolS
*symbol_lastP
;
218 struct xsymbol abs_symbol_x
;
220 struct xsymbol dot_symbol_x
;
223 #define debug_verify_symchain verify_symbol_chain
225 #define debug_verify_symchain(root, last) ((void) 0)
228 #define DOLLAR_LABEL_CHAR '\001'
229 #define LOCAL_LABEL_CHAR '\002'
231 #ifndef TC_LABEL_IS_LOCAL
232 #define TC_LABEL_IS_LOCAL(name) 0
235 struct obstack notes
;
237 /* The name of an external symbol which is
238 used to make weak PE symbol names unique. */
239 const char * an_external_name
;
242 static const char *save_symbol_name (const char *);
243 static void fb_label_init (void);
244 static long dollar_label_instance (long);
245 static long fb_label_instance (long);
247 static void print_binary (FILE *, const char *, expressionS
*);
249 /* Return a pointer to a new symbol. Die if we can't make a new
250 symbol. Fill in the symbol's values. Add symbol to end of symbol
253 This function should be called in the general case of creating a
254 symbol. However, if the output file symbol table has already been
255 set, and you are certain that this symbol won't be wanted in the
256 output file, you can call symbol_create. */
259 symbol_new (const char *name
, segT segment
, fragS
*frag
, valueT valu
)
261 symbolS
*symbolP
= symbol_create (name
, segment
, frag
, valu
);
263 /* Link to end of symbol chain. */
264 symbol_append (symbolP
, symbol_lastP
, &symbol_rootP
, &symbol_lastP
);
269 /* Save a symbol name on a permanent obstack, and convert it according
270 to the object file format. */
273 save_symbol_name (const char *name
)
278 gas_assert (name
!= NULL
);
279 name_length
= strlen (name
) + 1; /* +1 for \0. */
280 obstack_grow (¬es
, name
, name_length
);
281 ret
= (char *) obstack_finish (¬es
);
283 #ifdef tc_canonicalize_symbol_name
284 ret
= tc_canonicalize_symbol_name (ret
);
287 if (! symbols_case_sensitive
)
291 for (s
= ret
; *s
!= '\0'; s
++)
299 symbol_init (symbolS
*symbolP
, const char *name
, asection
*sec
,
300 fragS
*frag
, valueT valu
)
302 symbolP
->frag
= frag
;
303 symbolP
->bsym
= bfd_make_empty_symbol (stdoutput
);
304 if (symbolP
->bsym
== NULL
)
305 as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));
306 symbolP
->bsym
->name
= name
;
307 symbolP
->bsym
->section
= sec
;
309 S_SET_VALUE (symbolP
, valu
);
311 symbol_clear_list_pointers (symbolP
);
313 obj_symbol_new_hook (symbolP
);
315 #ifdef tc_symbol_new_hook
316 tc_symbol_new_hook (symbolP
);
320 /* Create a symbol. NAME is copied, the caller can destroy/modify. */
323 symbol_create (const char *name
, segT segment
, fragS
*frag
, valueT valu
)
325 const char *preserved_copy_of_name
;
329 preserved_copy_of_name
= save_symbol_name (name
);
331 size
= sizeof (symbolS
) + sizeof (struct xsymbol
);
332 symbolP
= (symbolS
*) obstack_alloc (¬es
, size
);
334 /* symbol must be born in some fixed state. This seems as good as any. */
335 memset (symbolP
, 0, size
);
336 symbolP
->name
= preserved_copy_of_name
;
337 symbolP
->x
= (struct xsymbol
*) (symbolP
+ 1);
339 symbol_init (symbolP
, preserved_copy_of_name
, segment
, frag
, valu
);
345 /* Local symbol support. If we can get away with it, we keep only a
346 small amount of information for local symbols. */
348 /* Used for statistics. */
350 static unsigned long local_symbol_count
;
351 static unsigned long local_symbol_conversion_count
;
353 /* Create a local symbol and insert it into the local hash table. */
355 struct local_symbol
*
356 local_symbol_make (const char *name
, segT section
, fragS
*frag
, valueT val
)
358 const char *name_copy
;
359 struct local_symbol
*ret
;
360 struct symbol_flags flags
= { .local_symbol
= 1, .resolved
= 0 };
362 ++local_symbol_count
;
364 name_copy
= save_symbol_name (name
);
366 ret
= (struct local_symbol
*) obstack_alloc (¬es
, sizeof *ret
);
369 ret
->name
= name_copy
;
371 ret
->section
= section
;
374 htab_insert (sy_hash
, ret
, 1);
379 /* Convert a local symbol into a real symbol. */
382 local_symbol_convert (void *sym
)
384 symbol_entry_t
*ent
= (symbol_entry_t
*) sym
;
385 struct xsymbol
*xtra
;
388 gas_assert (ent
->lsy
.flags
.local_symbol
);
390 ++local_symbol_conversion_count
;
392 xtra
= (struct xsymbol
*) obstack_alloc (¬es
, sizeof (*xtra
));
393 memset (xtra
, 0, sizeof (*xtra
));
394 val
= ent
->lsy
.value
;
397 /* Local symbols are always either defined or used. */
398 ent
->sy
.flags
.used
= 1;
399 ent
->sy
.flags
.local_symbol
= 0;
401 symbol_init (&ent
->sy
, ent
->lsy
.name
, ent
->lsy
.section
, ent
->lsy
.frag
, val
);
402 symbol_append (&ent
->sy
, symbol_lastP
, &symbol_rootP
, &symbol_lastP
);
408 define_sym_at_dot (symbolS
*symbolP
)
410 symbolP
->frag
= frag_now
;
411 S_SET_VALUE (symbolP
, (valueT
) frag_now_fix ());
412 S_SET_SEGMENT (symbolP
, now_seg
);
415 /* We have just seen "<name>:".
416 Creates a struct symbol unless it already exists.
418 Gripes if we are redefining a symbol incompatibly (and ignores it). */
421 colon (/* Just seen "x:" - rattle symbols & frags. */
422 const char *sym_name
/* Symbol name, as a canonical string. */
423 /* We copy this string: OK to alter later. */)
425 symbolS
*symbolP
; /* Symbol we are working with. */
427 /* Sun local labels go out of scope whenever a non-local symbol is
429 if (LOCAL_LABELS_DOLLAR
430 && !bfd_is_local_label_name (stdoutput
, sym_name
))
431 dollar_label_clear ();
433 #ifndef WORKING_DOT_WORD
434 if (new_broken_words
)
436 struct broken_word
*a
;
441 if (now_seg
== absolute_section
)
443 as_bad (_("cannot define symbol `%s' in absolute section"), sym_name
);
447 possible_bytes
= (md_short_jump_size
448 + new_broken_words
* md_long_jump_size
);
451 frag_opcode
= frag_var (rs_broken_word
,
455 (symbolS
*) broken_words
,
459 /* We want to store the pointer to where to insert the jump
460 table in the fr_opcode of the rs_broken_word frag. This
461 requires a little hackery. */
463 && (frag_tmp
->fr_type
!= rs_broken_word
464 || frag_tmp
->fr_opcode
))
465 frag_tmp
= frag_tmp
->fr_next
;
467 frag_tmp
->fr_opcode
= frag_opcode
;
468 new_broken_words
= 0;
470 for (a
= broken_words
; a
&& a
->dispfrag
== 0; a
= a
->next_broken_word
)
471 a
->dispfrag
= frag_tmp
;
473 #endif /* WORKING_DOT_WORD */
475 #ifdef obj_frob_colon
476 obj_frob_colon (sym_name
);
479 if ((symbolP
= symbol_find (sym_name
)) != 0)
481 S_CLEAR_WEAKREFR (symbolP
);
482 #ifdef RESOLVE_SYMBOL_REDEFINITION
483 if (RESOLVE_SYMBOL_REDEFINITION (symbolP
))
486 /* Now check for undefined symbols. */
487 if (symbolP
->flags
.local_symbol
)
489 struct local_symbol
*locsym
= (struct local_symbol
*) symbolP
;
491 if (locsym
->section
!= undefined_section
492 && (locsym
->frag
!= frag_now
493 || locsym
->section
!= now_seg
494 || locsym
->value
!= frag_now_fix ()))
496 as_bad (_("symbol `%s' is already defined"), sym_name
);
500 locsym
->section
= now_seg
;
501 locsym
->frag
= frag_now
;
502 locsym
->value
= frag_now_fix ();
504 else if (!(S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
505 || S_IS_COMMON (symbolP
)
506 || S_IS_VOLATILE (symbolP
))
508 if (S_IS_VOLATILE (symbolP
))
510 symbolP
= symbol_clone (symbolP
, 1);
511 S_SET_VALUE (symbolP
, 0);
512 S_CLEAR_VOLATILE (symbolP
);
514 if (S_GET_VALUE (symbolP
) == 0)
516 define_sym_at_dot (symbolP
);
519 #endif /* if we have one, it better be zero. */
524 /* There are still several cases to check:
526 A .comm/.lcomm symbol being redefined as initialized
529 A .comm/.lcomm symbol being redefined with a larger
532 This only used to be allowed on VMS gas, but Sun cc
533 on the sparc also depends on it. */
535 if (((!S_IS_DEBUG (symbolP
)
536 && (!S_IS_DEFINED (symbolP
) || S_IS_COMMON (symbolP
))
537 && S_IS_EXTERNAL (symbolP
))
538 || S_GET_SEGMENT (symbolP
) == bss_section
)
539 && (now_seg
== data_section
540 || now_seg
== bss_section
541 || now_seg
== S_GET_SEGMENT (symbolP
)))
543 /* Select which of the 2 cases this is. */
544 if (now_seg
!= data_section
)
546 /* New .comm for prev .comm symbol.
548 If the new size is larger we just change its
549 value. If the new size is smaller, we ignore
551 if (S_GET_VALUE (symbolP
)
552 < ((unsigned) frag_now_fix ()))
554 S_SET_VALUE (symbolP
, (valueT
) frag_now_fix ());
559 /* It is a .comm/.lcomm being converted to initialized
561 define_sym_at_dot (symbolP
);
566 #if (!defined (OBJ_AOUT) && !defined (OBJ_MAYBE_AOUT))
567 static const char *od_buf
= "";
571 if (OUTPUT_FLAVOR
== bfd_target_aout_flavour
)
572 sprintf (od_buf
, "%d.%d.",
573 S_GET_OTHER (symbolP
),
574 S_GET_DESC (symbolP
));
576 as_bad (_("symbol `%s' is already defined as \"%s\"/%s%ld"),
578 segment_name (S_GET_SEGMENT (symbolP
)),
580 (long) S_GET_VALUE (symbolP
));
582 } /* if the undefined symbol has no value */
586 /* Don't blow up if the definition is the same. */
587 if (!(frag_now
== symbolP
->frag
588 && S_GET_VALUE (symbolP
) == frag_now_fix ()
589 && S_GET_SEGMENT (symbolP
) == now_seg
))
591 as_bad (_("symbol `%s' is already defined"), sym_name
);
592 symbolP
= symbol_clone (symbolP
, 0);
593 define_sym_at_dot (symbolP
);
598 else if (! flag_keep_locals
&& bfd_is_local_label_name (stdoutput
, sym_name
))
600 symbolP
= (symbolS
*) local_symbol_make (sym_name
, now_seg
, frag_now
,
605 symbolP
= symbol_new (sym_name
, now_seg
, frag_now
, frag_now_fix ());
607 symbol_table_insert (symbolP
);
610 if (mri_common_symbol
!= NULL
)
612 /* This symbol is actually being defined within an MRI common
613 section. This requires special handling. */
614 if (symbolP
->flags
.local_symbol
)
615 symbolP
= local_symbol_convert (symbolP
);
616 symbolP
->x
->value
.X_op
= O_symbol
;
617 symbolP
->x
->value
.X_add_symbol
= mri_common_symbol
;
618 symbolP
->x
->value
.X_add_number
= S_GET_VALUE (mri_common_symbol
);
619 symbolP
->frag
= &zero_address_frag
;
620 S_SET_SEGMENT (symbolP
, expr_section
);
621 symbolP
->flags
.mri_common
= 1;
625 tc_frob_label (symbolP
);
627 #ifdef obj_frob_label
628 obj_frob_label (symbolP
);
634 /* Die if we can't insert the symbol. */
637 symbol_table_insert (symbolS
*symbolP
)
641 htab_insert (sy_hash
, symbolP
, 1);
644 /* If a symbol name does not exist, create it as undefined, and insert
645 it into the symbol table. Return a pointer to it. */
648 symbol_find_or_make (const char *name
)
652 symbolP
= symbol_find (name
);
656 if (! flag_keep_locals
&& bfd_is_local_label_name (stdoutput
, name
))
658 symbolP
= md_undefined_symbol ((char *) name
);
662 symbolP
= (symbolS
*) local_symbol_make (name
, undefined_section
,
663 &zero_address_frag
, 0);
667 symbolP
= symbol_make (name
);
669 symbol_table_insert (symbolP
);
670 } /* if symbol wasn't found */
676 symbol_make (const char *name
)
680 /* Let the machine description default it, e.g. for register names. */
681 symbolP
= md_undefined_symbol ((char *) name
);
684 symbolP
= symbol_new (name
, undefined_section
, &zero_address_frag
, 0);
690 symbol_clone (symbolS
*orgsymP
, int replace
)
693 asymbol
*bsymorg
, *bsymnew
;
695 /* Make sure we never clone the dot special symbol. */
696 gas_assert (orgsymP
!= &dot_symbol
);
698 /* When cloning a local symbol it isn't absolutely necessary to
699 convert the original, but converting makes the code much
700 simpler to cover this unexpected case. As of 2020-08-21
701 symbol_clone won't be called on a local symbol. */
702 if (orgsymP
->flags
.local_symbol
)
703 orgsymP
= local_symbol_convert (orgsymP
);
704 bsymorg
= orgsymP
->bsym
;
706 newsymP
= (symbolS
*) obstack_alloc (¬es
, (sizeof (symbolS
)
707 + sizeof (struct xsymbol
)));
709 newsymP
->x
= (struct xsymbol
*) (newsymP
+ 1);
710 *newsymP
->x
= *orgsymP
->x
;
711 bsymnew
= bfd_make_empty_symbol (bfd_asymbol_bfd (bsymorg
));
713 as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));
714 newsymP
->bsym
= bsymnew
;
715 bsymnew
->name
= bsymorg
->name
;
716 bsymnew
->flags
= bsymorg
->flags
& ~BSF_SECTION_SYM
;
717 bsymnew
->section
= bsymorg
->section
;
718 bfd_copy_private_symbol_data (bfd_asymbol_bfd (bsymorg
), bsymorg
,
719 bfd_asymbol_bfd (bsymnew
), bsymnew
);
721 #ifdef obj_symbol_clone_hook
722 obj_symbol_clone_hook (newsymP
, orgsymP
);
725 #ifdef tc_symbol_clone_hook
726 tc_symbol_clone_hook (newsymP
, orgsymP
);
731 if (symbol_rootP
== orgsymP
)
732 symbol_rootP
= newsymP
;
733 else if (orgsymP
->x
->previous
)
735 orgsymP
->x
->previous
->x
->next
= newsymP
;
736 orgsymP
->x
->previous
= NULL
;
738 if (symbol_lastP
== orgsymP
)
739 symbol_lastP
= newsymP
;
740 else if (orgsymP
->x
->next
)
741 orgsymP
->x
->next
->x
->previous
= newsymP
;
743 /* Symbols that won't be output can't be external. */
744 S_CLEAR_EXTERNAL (orgsymP
);
745 orgsymP
->x
->previous
= orgsymP
->x
->next
= orgsymP
;
746 debug_verify_symchain (symbol_rootP
, symbol_lastP
);
748 symbol_table_insert (newsymP
);
752 /* Symbols that won't be output can't be external. */
753 S_CLEAR_EXTERNAL (newsymP
);
754 newsymP
->x
->previous
= newsymP
->x
->next
= newsymP
;
760 /* Referenced symbols, if they are forward references, need to be cloned
761 (without replacing the original) so that the value of the referenced
762 symbols at the point of use is saved by the clone. */
764 #undef symbol_clone_if_forward_ref
766 symbol_clone_if_forward_ref (symbolS
*symbolP
, int is_forward
)
768 if (symbolP
&& !symbolP
->flags
.local_symbol
)
770 symbolS
*orig_add_symbol
= symbolP
->x
->value
.X_add_symbol
;
771 symbolS
*orig_op_symbol
= symbolP
->x
->value
.X_op_symbol
;
772 symbolS
*add_symbol
= orig_add_symbol
;
773 symbolS
*op_symbol
= orig_op_symbol
;
775 if (symbolP
->flags
.forward_ref
)
780 /* assign_symbol() clones volatile symbols; pre-existing expressions
781 hold references to the original instance, but want the current
782 value. Just repeat the lookup. */
783 if (add_symbol
&& S_IS_VOLATILE (add_symbol
))
784 add_symbol
= symbol_find_exact (S_GET_NAME (add_symbol
));
785 if (op_symbol
&& S_IS_VOLATILE (op_symbol
))
786 op_symbol
= symbol_find_exact (S_GET_NAME (op_symbol
));
789 /* Re-using resolving here, as this routine cannot get called from
790 symbol resolution code. */
791 if ((symbolP
->bsym
->section
== expr_section
792 || symbolP
->flags
.forward_ref
)
793 && !symbolP
->flags
.resolving
)
795 symbolP
->flags
.resolving
= 1;
796 add_symbol
= symbol_clone_if_forward_ref (add_symbol
, is_forward
);
797 op_symbol
= symbol_clone_if_forward_ref (op_symbol
, is_forward
);
798 symbolP
->flags
.resolving
= 0;
801 if (symbolP
->flags
.forward_ref
802 || add_symbol
!= orig_add_symbol
803 || op_symbol
!= orig_op_symbol
)
805 if (symbolP
!= &dot_symbol
)
807 symbolP
= symbol_clone (symbolP
, 0);
808 symbolP
->flags
.resolving
= 0;
812 symbolP
= symbol_temp_new_now ();
813 #ifdef tc_new_dot_label
814 tc_new_dot_label (symbolP
);
819 symbolP
->x
->value
.X_add_symbol
= add_symbol
;
820 symbolP
->x
->value
.X_op_symbol
= op_symbol
;
827 symbol_temp_new (segT seg
, fragS
*frag
, valueT ofs
)
829 return symbol_new (FAKE_LABEL_NAME
, seg
, frag
, ofs
);
833 symbol_temp_new_now (void)
835 return symbol_temp_new (now_seg
, frag_now
, frag_now_fix ());
839 symbol_temp_new_now_octets (void)
841 return symbol_temp_new (now_seg
, frag_now
, frag_now_fix_octets ());
845 symbol_temp_make (void)
847 return symbol_make (FAKE_LABEL_NAME
);
850 /* Implement symbol table lookup.
851 In: A symbol's name as a string: '\0' can't be part of a symbol name.
852 Out: NULL if the name was not in the symbol table, else the address
853 of a struct symbol associated with that name. */
856 symbol_find_exact (const char *name
)
858 return symbol_find_exact_noref (name
, 0);
862 symbol_find_exact_noref (const char *name
, int noref
)
864 symbolS
*sym
= symbol_entry_find (sy_hash
, name
);
866 /* Any references to the symbol, except for the reference in
867 .weakref, must clear this flag, such that the symbol does not
868 turn into a weak symbol. Note that we don't have to handle the
869 local_symbol case, since a weakrefd is always promoted out of the
870 local_symbol table when it is turned into a weak symbol. */
872 S_CLEAR_WEAKREFD (sym
);
878 symbol_find (const char *name
)
880 return symbol_find_noref (name
, 0);
884 symbol_find_noref (const char *name
, int noref
)
889 #ifdef tc_canonicalize_symbol_name
891 copy
= xstrdup (name
);
892 name
= tc_canonicalize_symbol_name (copy
);
896 if (! symbols_case_sensitive
)
905 name
= copy
= XNEWVEC (char, strlen (name
) + 1);
907 while ((c
= *orig
++) != '\0')
908 *copy
++ = TOUPPER (c
);
912 copy
= (char *) name
;
915 result
= symbol_find_exact_noref (name
, noref
);
920 /* Once upon a time, symbols were kept in a singly linked list. At
921 least coff needs to be able to rearrange them from time to time, for
922 which a doubly linked list is much more convenient. Loic did these
923 as macros which seemed dangerous to me so they're now functions.
926 /* Link symbol ADDME after symbol TARGET in the chain. */
929 symbol_append (symbolS
*addme
, symbolS
*target
,
930 symbolS
**rootPP
, symbolS
**lastPP
)
932 extern int symbol_table_frozen
;
933 if (symbol_table_frozen
)
935 if (addme
->flags
.local_symbol
)
937 if (target
!= NULL
&& target
->flags
.local_symbol
)
942 know (*rootPP
== NULL
);
943 know (*lastPP
== NULL
);
944 addme
->x
->next
= NULL
;
945 addme
->x
->previous
= NULL
;
949 } /* if the list is empty */
951 if (target
->x
->next
!= NULL
)
953 target
->x
->next
->x
->previous
= addme
;
957 know (*lastPP
== target
);
959 } /* if we have a next */
961 addme
->x
->next
= target
->x
->next
;
962 target
->x
->next
= addme
;
963 addme
->x
->previous
= target
;
965 debug_verify_symchain (symbol_rootP
, symbol_lastP
);
968 /* Set the chain pointers of SYMBOL to null. */
971 symbol_clear_list_pointers (symbolS
*symbolP
)
973 if (symbolP
->flags
.local_symbol
)
975 symbolP
->x
->next
= NULL
;
976 symbolP
->x
->previous
= NULL
;
979 /* Remove SYMBOLP from the list. */
982 symbol_remove (symbolS
*symbolP
, symbolS
**rootPP
, symbolS
**lastPP
)
984 if (symbolP
->flags
.local_symbol
)
987 if (symbolP
== *rootPP
)
989 *rootPP
= symbolP
->x
->next
;
990 } /* if it was the root */
992 if (symbolP
== *lastPP
)
994 *lastPP
= symbolP
->x
->previous
;
995 } /* if it was the tail */
997 if (symbolP
->x
->next
!= NULL
)
999 symbolP
->x
->next
->x
->previous
= symbolP
->x
->previous
;
1002 if (symbolP
->x
->previous
!= NULL
)
1004 symbolP
->x
->previous
->x
->next
= symbolP
->x
->next
;
1005 } /* if not first */
1007 debug_verify_symchain (*rootPP
, *lastPP
);
1010 /* Link symbol ADDME before symbol TARGET in the chain. */
1013 symbol_insert (symbolS
*addme
, symbolS
*target
,
1014 symbolS
**rootPP
, symbolS
**lastPP ATTRIBUTE_UNUSED
)
1016 extern int symbol_table_frozen
;
1017 if (symbol_table_frozen
)
1019 if (addme
->flags
.local_symbol
)
1021 if (target
->flags
.local_symbol
)
1024 if (target
->x
->previous
!= NULL
)
1026 target
->x
->previous
->x
->next
= addme
;
1030 know (*rootPP
== target
);
1032 } /* if not first */
1034 addme
->x
->previous
= target
->x
->previous
;
1035 target
->x
->previous
= addme
;
1036 addme
->x
->next
= target
;
1038 debug_verify_symchain (*rootPP
, *lastPP
);
1042 verify_symbol_chain (symbolS
*rootP
, symbolS
*lastP
)
1044 symbolS
*symbolP
= rootP
;
1046 if (symbolP
== NULL
)
1049 for (; symbol_next (symbolP
) != NULL
; symbolP
= symbol_next (symbolP
))
1051 gas_assert (symbolP
->bsym
!= NULL
);
1052 gas_assert (symbolP
->flags
.local_symbol
== 0);
1053 gas_assert (symbolP
->x
->next
->x
->previous
== symbolP
);
1056 gas_assert (lastP
== symbolP
);
1060 symbol_on_chain (symbolS
*s
, symbolS
*rootPP
, symbolS
*lastPP
)
1062 return (!s
->flags
.local_symbol
1063 && ((s
->x
->next
!= s
1064 && s
->x
->next
!= NULL
1065 && s
->x
->next
->x
->previous
== s
)
1067 && ((s
->x
->previous
!= s
1068 && s
->x
->previous
!= NULL
1069 && s
->x
->previous
->x
->next
== s
)
1073 #ifdef OBJ_COMPLEX_RELC
1076 use_complex_relocs_for (symbolS
* symp
)
1078 switch (symp
->x
->value
.X_op
)
1088 case O_bit_inclusive_or
:
1090 case O_bit_exclusive_or
:
1102 if ((S_IS_COMMON (symp
->x
->value
.X_op_symbol
)
1103 || S_IS_LOCAL (symp
->x
->value
.X_op_symbol
))
1104 && S_IS_DEFINED (symp
->x
->value
.X_op_symbol
)
1105 && S_GET_SEGMENT (symp
->x
->value
.X_op_symbol
) != expr_section
)
1112 if ((S_IS_COMMON (symp
->x
->value
.X_add_symbol
)
1113 || S_IS_LOCAL (symp
->x
->value
.X_add_symbol
))
1114 && S_IS_DEFINED (symp
->x
->value
.X_add_symbol
)
1115 && S_GET_SEGMENT (symp
->x
->value
.X_add_symbol
) != expr_section
)
1128 report_op_error (symbolS
*symp
, symbolS
*left
, operatorT op
, symbolS
*right
)
1132 segT seg_left
= left
? S_GET_SEGMENT (left
) : 0;
1133 segT seg_right
= S_GET_SEGMENT (right
);
1142 case O_uminus
: opname
= "-"; break;
1143 case O_bit_not
: opname
= "~"; break;
1144 case O_logical_not
: opname
= "!"; break;
1145 case O_multiply
: opname
= "*"; break;
1146 case O_divide
: opname
= "/"; break;
1147 case O_modulus
: opname
= "%"; break;
1148 case O_left_shift
: opname
= "<<"; break;
1149 case O_right_shift
: opname
= ">>"; break;
1150 case O_bit_inclusive_or
: opname
= "|"; break;
1151 case O_bit_or_not
: opname
= "|~"; break;
1152 case O_bit_exclusive_or
: opname
= "^"; break;
1153 case O_bit_and
: opname
= "&"; break;
1154 case O_add
: opname
= "+"; break;
1155 case O_subtract
: opname
= "-"; break;
1156 case O_eq
: opname
= "=="; break;
1157 case O_ne
: opname
= "!="; break;
1158 case O_lt
: opname
= "<"; break;
1159 case O_le
: opname
= "<="; break;
1160 case O_ge
: opname
= ">="; break;
1161 case O_gt
: opname
= ">"; break;
1162 case O_logical_and
: opname
= "&&"; break;
1163 case O_logical_or
: opname
= "||"; break;
1166 if (expr_symbol_where (symp
, &file
, &line
))
1169 as_bad_where (file
, line
,
1170 _("invalid operands (%s and %s sections) for `%s'"),
1171 seg_left
->name
, seg_right
->name
, opname
);
1173 as_bad_where (file
, line
,
1174 _("invalid operand (%s section) for `%s'"),
1175 seg_right
->name
, opname
);
1179 const char *sname
= S_GET_NAME (symp
);
1182 as_bad (_("invalid operands (%s and %s sections) for `%s' when setting `%s'"),
1183 seg_left
->name
, seg_right
->name
, opname
, sname
);
1185 as_bad (_("invalid operand (%s section) for `%s' when setting `%s'"),
1186 seg_right
->name
, opname
, sname
);
1190 /* Resolve the value of a symbol. This is called during the final
1191 pass over the symbol table to resolve any symbols with complex
1195 resolve_symbol_value (symbolS
*symp
)
1201 if (symp
->flags
.local_symbol
)
1203 struct local_symbol
*locsym
= (struct local_symbol
*) symp
;
1205 final_val
= locsym
->value
;
1206 if (locsym
->flags
.resolved
)
1209 /* Symbols whose section has SEC_ELF_OCTETS set,
1210 resolve to octets instead of target bytes. */
1211 if (locsym
->section
->flags
& SEC_OCTETS
)
1212 final_val
+= locsym
->frag
->fr_address
;
1214 final_val
+= locsym
->frag
->fr_address
/ OCTETS_PER_BYTE
;
1218 locsym
->value
= final_val
;
1219 locsym
->flags
.resolved
= 1;
1225 if (symp
->flags
.resolved
)
1228 while (symp
->x
->value
.X_op
== O_symbol
)
1230 final_val
+= symp
->x
->value
.X_add_number
;
1231 symp
= symp
->x
->value
.X_add_symbol
;
1232 if (symp
->flags
.local_symbol
)
1234 struct local_symbol
*locsym
= (struct local_symbol
*) symp
;
1235 final_val
+= locsym
->value
;
1238 if (!symp
->flags
.resolved
)
1241 if (symp
->x
->value
.X_op
== O_constant
)
1242 final_val
+= symp
->x
->value
.X_add_number
;
1249 final_seg
= S_GET_SEGMENT (symp
);
1251 if (symp
->flags
.resolving
)
1254 as_bad (_("symbol definition loop encountered at `%s'"),
1259 #ifdef OBJ_COMPLEX_RELC
1260 else if (final_seg
== expr_section
1261 && use_complex_relocs_for (symp
))
1263 symbolS
* relc_symbol
= NULL
;
1264 char * relc_symbol_name
= NULL
;
1266 relc_symbol_name
= symbol_relc_make_expr (& symp
->x
->value
);
1268 /* For debugging, print out conversion input & output. */
1270 print_expr (& symp
->x
->value
);
1271 if (relc_symbol_name
)
1272 fprintf (stderr
, "-> relc symbol: %s\n", relc_symbol_name
);
1275 if (relc_symbol_name
!= NULL
)
1276 relc_symbol
= symbol_new (relc_symbol_name
, undefined_section
,
1277 &zero_address_frag
, 0);
1279 if (relc_symbol
== NULL
)
1281 as_bad (_("cannot convert expression symbol %s to complex relocation"),
1287 symbol_table_insert (relc_symbol
);
1289 /* S_CLEAR_EXTERNAL (relc_symbol); */
1290 if (symp
->bsym
->flags
& BSF_SRELC
)
1291 relc_symbol
->bsym
->flags
|= BSF_SRELC
;
1293 relc_symbol
->bsym
->flags
|= BSF_RELC
;
1294 /* symp->bsym->flags |= BSF_RELC; */
1295 copy_symbol_attributes (symp
, relc_symbol
);
1296 symp
->x
->value
.X_op
= O_symbol
;
1297 symp
->x
->value
.X_add_symbol
= relc_symbol
;
1298 symp
->x
->value
.X_add_number
= 0;
1303 final_seg
= undefined_section
;
1304 goto exit_dont_set_value
;
1309 symbolS
*add_symbol
, *op_symbol
;
1310 offsetT left
, right
;
1311 segT seg_left
, seg_right
;
1315 symp
->flags
.resolving
= 1;
1317 /* Help out with CSE. */
1318 add_symbol
= symp
->x
->value
.X_add_symbol
;
1319 op_symbol
= symp
->x
->value
.X_op_symbol
;
1320 final_val
= symp
->x
->value
.X_add_number
;
1321 op
= symp
->x
->value
.X_op
;
1334 /* Symbols whose section has SEC_ELF_OCTETS set,
1335 resolve to octets instead of target bytes. */
1336 if (symp
->bsym
->section
->flags
& SEC_OCTETS
)
1337 final_val
+= symp
->frag
->fr_address
;
1339 final_val
+= symp
->frag
->fr_address
/ OCTETS_PER_BYTE
;
1340 if (final_seg
== expr_section
)
1341 final_seg
= absolute_section
;
1350 left
= resolve_symbol_value (add_symbol
);
1351 seg_left
= S_GET_SEGMENT (add_symbol
);
1353 symp
->x
->value
.X_op_symbol
= NULL
;
1356 if (S_IS_WEAKREFR (symp
))
1358 gas_assert (final_val
== 0);
1359 if (S_IS_WEAKREFR (add_symbol
))
1361 gas_assert (add_symbol
->x
->value
.X_op
== O_symbol
1362 && add_symbol
->x
->value
.X_add_number
== 0);
1363 add_symbol
= add_symbol
->x
->value
.X_add_symbol
;
1364 gas_assert (! S_IS_WEAKREFR (add_symbol
));
1365 symp
->x
->value
.X_add_symbol
= add_symbol
;
1369 if (symp
->flags
.mri_common
)
1371 /* This is a symbol inside an MRI common section. The
1372 relocation routines are going to handle it specially.
1373 Don't change the value. */
1374 resolved
= symbol_resolved_p (add_symbol
);
1378 /* Don't leave symbol loops. */
1380 && !add_symbol
->flags
.local_symbol
1381 && add_symbol
->flags
.resolving
)
1384 if (finalize_syms
&& final_val
== 0)
1386 if (add_symbol
->flags
.local_symbol
)
1387 add_symbol
= local_symbol_convert (add_symbol
);
1388 copy_symbol_attributes (symp
, add_symbol
);
1391 /* If we have equated this symbol to an undefined or common
1392 symbol, keep X_op set to O_symbol, and don't change
1393 X_add_number. This permits the routine which writes out
1394 relocation to detect this case, and convert the
1395 relocation to be against the symbol to which this symbol
1397 if (seg_left
== undefined_section
1398 || bfd_is_com_section (seg_left
)
1399 #if defined (OBJ_COFF) && defined (TE_PE)
1400 || S_IS_WEAK (add_symbol
)
1403 && ((final_seg
== expr_section
1404 && seg_left
!= expr_section
1405 && seg_left
!= absolute_section
)
1406 || symbol_shadow_p (symp
))))
1410 symp
->x
->value
.X_op
= O_symbol
;
1411 symp
->x
->value
.X_add_symbol
= add_symbol
;
1412 symp
->x
->value
.X_add_number
= final_val
;
1413 /* Use X_op_symbol as a flag. */
1414 symp
->x
->value
.X_op_symbol
= add_symbol
;
1416 final_seg
= seg_left
;
1417 final_val
+= symp
->frag
->fr_address
+ left
;
1418 resolved
= symbol_resolved_p (add_symbol
);
1419 symp
->flags
.resolving
= 0;
1420 goto exit_dont_set_value
;
1424 final_val
+= symp
->frag
->fr_address
+ left
;
1425 if (final_seg
== expr_section
|| final_seg
== undefined_section
)
1426 final_seg
= seg_left
;
1429 resolved
= symbol_resolved_p (add_symbol
);
1430 if (S_IS_WEAKREFR (symp
))
1432 symp
->flags
.resolving
= 0;
1433 goto exit_dont_set_value
;
1440 left
= resolve_symbol_value (add_symbol
);
1441 seg_left
= S_GET_SEGMENT (add_symbol
);
1443 /* By reducing these to the relevant dyadic operator, we get
1444 !S -> S == 0 permitted on anything,
1445 -S -> 0 - S only permitted on absolute
1446 ~S -> S ^ ~0 only permitted on absolute */
1447 if (op
!= O_logical_not
&& seg_left
!= absolute_section
1449 report_op_error (symp
, NULL
, op
, add_symbol
);
1451 if (final_seg
== expr_section
|| final_seg
== undefined_section
)
1452 final_seg
= absolute_section
;
1456 else if (op
== O_logical_not
)
1461 final_val
+= left
+ symp
->frag
->fr_address
;
1463 resolved
= symbol_resolved_p (add_symbol
);
1471 case O_bit_inclusive_or
:
1473 case O_bit_exclusive_or
:
1485 left
= resolve_symbol_value (add_symbol
);
1486 right
= resolve_symbol_value (op_symbol
);
1487 seg_left
= S_GET_SEGMENT (add_symbol
);
1488 seg_right
= S_GET_SEGMENT (op_symbol
);
1490 /* Simplify addition or subtraction of a constant by folding the
1491 constant into X_add_number. */
1494 if (seg_right
== absolute_section
)
1499 else if (seg_left
== absolute_section
)
1502 add_symbol
= op_symbol
;
1504 seg_left
= seg_right
;
1508 else if (op
== O_subtract
)
1510 if (seg_right
== absolute_section
)
1518 /* Equality and non-equality tests are permitted on anything.
1519 Subtraction, and other comparison operators are permitted if
1520 both operands are in the same section. Otherwise, both
1521 operands must be absolute. We already handled the case of
1522 addition or subtraction of a constant above. This will
1523 probably need to be changed for an object file format which
1524 supports arbitrary expressions. */
1525 if (!(seg_left
== absolute_section
1526 && seg_right
== absolute_section
)
1527 && !(op
== O_eq
|| op
== O_ne
)
1528 && !((op
== O_subtract
1529 || op
== O_lt
|| op
== O_le
|| op
== O_ge
|| op
== O_gt
)
1530 && seg_left
== seg_right
1531 && (seg_left
!= undefined_section
1532 || add_symbol
== op_symbol
)))
1534 /* Don't emit messages unless we're finalizing the symbol value,
1535 otherwise we may get the same message multiple times. */
1537 report_op_error (symp
, add_symbol
, op
, op_symbol
);
1538 /* However do not move the symbol into the absolute section
1539 if it cannot currently be resolved - this would confuse
1540 other parts of the assembler into believing that the
1541 expression had been evaluated to zero. */
1547 && (final_seg
== expr_section
|| final_seg
== undefined_section
))
1548 final_seg
= absolute_section
;
1550 /* Check for division by zero. */
1551 if ((op
== O_divide
|| op
== O_modulus
) && right
== 0)
1553 /* If seg_right is not absolute_section, then we've
1554 already issued a warning about using a bad symbol. */
1555 if (seg_right
== absolute_section
&& finalize_syms
)
1560 if (expr_symbol_where (symp
, &file
, &line
))
1561 as_bad_where (file
, line
, _("division by zero"));
1563 as_bad (_("division by zero when setting `%s'"),
1569 if ((op
== O_left_shift
|| op
== O_right_shift
)
1570 && (valueT
) right
>= sizeof (valueT
) * CHAR_BIT
)
1572 as_warn_value_out_of_range (_("shift count"), right
, 0,
1573 sizeof (valueT
) * CHAR_BIT
- 1,
1578 switch (symp
->x
->value
.X_op
)
1580 case O_multiply
: left
*= right
; break;
1581 case O_divide
: left
/= right
; break;
1582 case O_modulus
: left
%= right
; break;
1584 left
= (valueT
) left
<< (valueT
) right
; break;
1586 left
= (valueT
) left
>> (valueT
) right
; break;
1587 case O_bit_inclusive_or
: left
|= right
; break;
1588 case O_bit_or_not
: left
|= ~right
; break;
1589 case O_bit_exclusive_or
: left
^= right
; break;
1590 case O_bit_and
: left
&= right
; break;
1591 case O_add
: left
+= right
; break;
1592 case O_subtract
: left
-= right
; break;
1595 left
= (left
== right
&& seg_left
== seg_right
1596 && (seg_left
!= undefined_section
1597 || add_symbol
== op_symbol
)
1598 ? ~ (offsetT
) 0 : 0);
1599 if (symp
->x
->value
.X_op
== O_ne
)
1602 case O_lt
: left
= left
< right
? ~ (offsetT
) 0 : 0; break;
1603 case O_le
: left
= left
<= right
? ~ (offsetT
) 0 : 0; break;
1604 case O_ge
: left
= left
>= right
? ~ (offsetT
) 0 : 0; break;
1605 case O_gt
: left
= left
> right
? ~ (offsetT
) 0 : 0; break;
1606 case O_logical_and
: left
= left
&& right
; break;
1607 case O_logical_or
: left
= left
|| right
; break;
1612 /* See PR 20895 for a reproducer. */
1613 as_bad (_("Invalid operation on symbol"));
1614 goto exit_dont_set_value
;
1620 final_val
+= symp
->frag
->fr_address
+ left
;
1621 if (final_seg
== expr_section
|| final_seg
== undefined_section
)
1623 if (seg_left
== undefined_section
1624 || seg_right
== undefined_section
)
1625 final_seg
= undefined_section
;
1626 else if (seg_left
== absolute_section
)
1627 final_seg
= seg_right
;
1629 final_seg
= seg_left
;
1631 resolved
= (symbol_resolved_p (add_symbol
)
1632 && symbol_resolved_p (op_symbol
));
1637 /* Give an error (below) if not in expr_section. We don't
1638 want to worry about expr_section symbols, because they
1639 are fictional (they are created as part of expression
1640 resolution), and any problems may not actually mean
1645 symp
->flags
.resolving
= 0;
1649 S_SET_VALUE (symp
, final_val
);
1651 exit_dont_set_value
:
1652 /* Always set the segment, even if not finalizing the value.
1653 The segment is used to determine whether a symbol is defined. */
1654 S_SET_SEGMENT (symp
, final_seg
);
1656 /* Don't worry if we can't resolve an expr_section symbol. */
1660 symp
->flags
.resolved
= 1;
1661 else if (S_GET_SEGMENT (symp
) != expr_section
)
1663 as_bad (_("can't resolve value for symbol `%s'"),
1665 symp
->flags
.resolved
= 1;
1672 /* A static function passed to hash_traverse. */
1675 resolve_local_symbol (void **slot
, void *arg ATTRIBUTE_UNUSED
)
1677 symbol_entry_t
*entry
= *((symbol_entry_t
**) slot
);
1678 if (entry
->sy
.flags
.local_symbol
)
1679 resolve_symbol_value (&entry
->sy
);
1684 /* Resolve all local symbols. */
1687 resolve_local_symbol_values (void)
1689 htab_traverse (sy_hash
, resolve_local_symbol
, NULL
);
1692 /* Obtain the current value of a symbol without changing any
1693 sub-expressions used. */
1696 snapshot_symbol (symbolS
**symbolPP
, valueT
*valueP
, segT
*segP
, fragS
**fragPP
)
1698 symbolS
*symbolP
= *symbolPP
;
1700 if (symbolP
->flags
.local_symbol
)
1702 struct local_symbol
*locsym
= (struct local_symbol
*) symbolP
;
1704 *valueP
= locsym
->value
;
1705 *segP
= locsym
->section
;
1706 *fragPP
= locsym
->frag
;
1710 expressionS exp
= symbolP
->x
->value
;
1712 if (!symbolP
->flags
.resolved
&& exp
.X_op
!= O_illegal
)
1716 if (symbolP
->flags
.resolving
)
1718 symbolP
->flags
.resolving
= 1;
1719 resolved
= resolve_expression (&exp
);
1720 symbolP
->flags
.resolving
= 0;
1728 if (!symbol_equated_p (symbolP
))
1733 symbolP
= exp
.X_add_symbol
;
1740 *symbolPP
= symbolP
;
1742 /* A bogus input file can result in resolve_expression()
1743 generating a local symbol, so we have to check again. */
1744 if (symbolP
->flags
.local_symbol
)
1746 struct local_symbol
*locsym
= (struct local_symbol
*) symbolP
;
1748 *valueP
= locsym
->value
;
1749 *segP
= locsym
->section
;
1750 *fragPP
= locsym
->frag
;
1754 *valueP
= exp
.X_add_number
;
1755 *segP
= symbolP
->bsym
->section
;
1756 *fragPP
= symbolP
->frag
;
1759 if (*segP
== expr_section
)
1762 case O_constant
: *segP
= absolute_section
; break;
1763 case O_register
: *segP
= reg_section
; break;
1771 /* Dollar labels look like a number followed by a dollar sign. Eg, "42$".
1772 They are *really* local. That is, they go out of scope whenever we see a
1773 label that isn't local. Also, like fb labels, there can be multiple
1774 instances of a dollar label. Therefor, we name encode each instance with
1775 the instance number, keep a list of defined symbols separate from the real
1776 symbol table, and we treat these buggers as a sparse array. */
1778 static long *dollar_labels
;
1779 static long *dollar_label_instances
;
1780 static char *dollar_label_defines
;
1781 static size_t dollar_label_count
;
1782 static size_t dollar_label_max
;
1785 dollar_label_defined (long label
)
1789 know ((dollar_labels
!= NULL
) || (dollar_label_count
== 0));
1791 for (i
= dollar_labels
; i
< dollar_labels
+ dollar_label_count
; ++i
)
1793 return dollar_label_defines
[i
- dollar_labels
];
1795 /* If we get here, label isn't defined. */
1800 dollar_label_instance (long label
)
1804 know ((dollar_labels
!= NULL
) || (dollar_label_count
== 0));
1806 for (i
= dollar_labels
; i
< dollar_labels
+ dollar_label_count
; ++i
)
1808 return (dollar_label_instances
[i
- dollar_labels
]);
1810 /* If we get here, we haven't seen the label before.
1811 Therefore its instance count is zero. */
1816 dollar_label_clear (void)
1818 if (dollar_label_count
)
1819 memset (dollar_label_defines
, '\0', dollar_label_count
);
1822 #define DOLLAR_LABEL_BUMP_BY 10
1825 define_dollar_label (long label
)
1829 for (i
= dollar_labels
; i
< dollar_labels
+ dollar_label_count
; ++i
)
1832 ++dollar_label_instances
[i
- dollar_labels
];
1833 dollar_label_defines
[i
- dollar_labels
] = 1;
1837 /* If we get to here, we don't have label listed yet. */
1839 if (dollar_labels
== NULL
)
1841 dollar_labels
= XNEWVEC (long, DOLLAR_LABEL_BUMP_BY
);
1842 dollar_label_instances
= XNEWVEC (long, DOLLAR_LABEL_BUMP_BY
);
1843 dollar_label_defines
= XNEWVEC (char, DOLLAR_LABEL_BUMP_BY
);
1844 dollar_label_max
= DOLLAR_LABEL_BUMP_BY
;
1845 dollar_label_count
= 0;
1847 else if (dollar_label_count
== dollar_label_max
)
1849 dollar_label_max
+= DOLLAR_LABEL_BUMP_BY
;
1850 dollar_labels
= XRESIZEVEC (long, dollar_labels
, dollar_label_max
);
1851 dollar_label_instances
= XRESIZEVEC (long, dollar_label_instances
,
1853 dollar_label_defines
= XRESIZEVEC (char, dollar_label_defines
,
1855 } /* if we needed to grow */
1857 dollar_labels
[dollar_label_count
] = label
;
1858 dollar_label_instances
[dollar_label_count
] = 1;
1859 dollar_label_defines
[dollar_label_count
] = 1;
1860 ++dollar_label_count
;
1863 /* Caller must copy returned name: we re-use the area for the next name.
1865 The mth occurrence of label n: is turned into the symbol "Ln^Am"
1866 where n is the label number and m is the instance number. "L" makes
1867 it a label discarded unless debugging and "^A"('\1') ensures no
1868 ordinary symbol SHOULD get the same name as a local label
1869 symbol. The first "4:" is "L4^A1" - the m numbers begin at 1.
1871 fb labels get the same treatment, except that ^B is used in place
1874 char * /* Return local label name. */
1875 dollar_label_name (long n
, /* we just saw "n$:" : n a number. */
1876 int augend
/* 0 for current instance, 1 for new instance. */)
1879 /* Returned to caller, then copied. Used for created names ("4f"). */
1880 static char symbol_name_build
[24];
1883 char symbol_name_temporary
[20]; /* Build up a number, BACKWARDS. */
1886 know (augend
== 0 || augend
== 1);
1887 p
= symbol_name_build
;
1888 #ifdef LOCAL_LABEL_PREFIX
1889 *p
++ = LOCAL_LABEL_PREFIX
;
1893 /* Next code just does sprintf( {}, "%d", n); */
1895 q
= symbol_name_temporary
;
1896 for (*q
++ = 0, i
= n
; i
; ++q
)
1901 while ((*p
= *--q
) != '\0')
1904 *p
++ = DOLLAR_LABEL_CHAR
; /* ^A */
1906 /* Instance number. */
1907 q
= symbol_name_temporary
;
1908 for (*q
++ = 0, i
= dollar_label_instance (n
) + augend
; i
; ++q
)
1913 while ((*p
++ = *--q
) != '\0');
1915 /* The label, as a '\0' ended string, starts at symbol_name_build. */
1916 return symbol_name_build
;
1919 /* Somebody else's idea of local labels. They are made by "n:" where n
1920 is any decimal digit. Refer to them with
1921 "nb" for previous (backward) n:
1922 or "nf" for next (forward) n:.
1924 We do a little better and let n be any number, not just a single digit, but
1925 since the other guy's assembler only does ten, we treat the first ten
1928 Like someone else's assembler, we have one set of local label counters for
1929 entire assembly, not one set per (sub)segment like in most assemblers. This
1930 implies that one can refer to a label in another segment, and indeed some
1931 crufty compilers have done just that.
1933 Since there could be a LOT of these things, treat them as a sparse
1936 #define FB_LABEL_SPECIAL (10)
1938 static long fb_low_counter
[FB_LABEL_SPECIAL
];
1939 static long *fb_labels
;
1940 static long *fb_label_instances
;
1941 static long fb_label_count
;
1942 static long fb_label_max
;
1944 /* This must be more than FB_LABEL_SPECIAL. */
1945 #define FB_LABEL_BUMP_BY (FB_LABEL_SPECIAL + 6)
1948 fb_label_init (void)
1950 memset ((void *) fb_low_counter
, '\0', sizeof (fb_low_counter
));
1953 /* Add one to the instance number of this fb label. */
1956 fb_label_instance_inc (long label
)
1960 if ((unsigned long) label
< FB_LABEL_SPECIAL
)
1962 ++fb_low_counter
[label
];
1966 if (fb_labels
!= NULL
)
1968 for (i
= fb_labels
+ FB_LABEL_SPECIAL
;
1969 i
< fb_labels
+ fb_label_count
; ++i
)
1973 ++fb_label_instances
[i
- fb_labels
];
1975 } /* if we find it */
1976 } /* for each existing label */
1979 /* If we get to here, we don't have label listed yet. */
1981 if (fb_labels
== NULL
)
1983 fb_labels
= XNEWVEC (long, FB_LABEL_BUMP_BY
);
1984 fb_label_instances
= XNEWVEC (long, FB_LABEL_BUMP_BY
);
1985 fb_label_max
= FB_LABEL_BUMP_BY
;
1986 fb_label_count
= FB_LABEL_SPECIAL
;
1989 else if (fb_label_count
== fb_label_max
)
1991 fb_label_max
+= FB_LABEL_BUMP_BY
;
1992 fb_labels
= XRESIZEVEC (long, fb_labels
, fb_label_max
);
1993 fb_label_instances
= XRESIZEVEC (long, fb_label_instances
, fb_label_max
);
1994 } /* if we needed to grow */
1996 fb_labels
[fb_label_count
] = label
;
1997 fb_label_instances
[fb_label_count
] = 1;
2002 fb_label_instance (long label
)
2006 if ((unsigned long) label
< FB_LABEL_SPECIAL
)
2008 return (fb_low_counter
[label
]);
2011 if (fb_labels
!= NULL
)
2013 for (i
= fb_labels
+ FB_LABEL_SPECIAL
;
2014 i
< fb_labels
+ fb_label_count
; ++i
)
2018 return (fb_label_instances
[i
- fb_labels
]);
2019 } /* if we find it */
2020 } /* for each existing label */
2023 /* We didn't find the label, so this must be a reference to the
2028 /* Caller must copy returned name: we re-use the area for the next name.
2030 The mth occurrence of label n: is turned into the symbol "Ln^Bm"
2031 where n is the label number and m is the instance number. "L" makes
2032 it a label discarded unless debugging and "^B"('\2') ensures no
2033 ordinary symbol SHOULD get the same name as a local label
2034 symbol. The first "4:" is "L4^B1" - the m numbers begin at 1.
2036 dollar labels get the same treatment, except that ^A is used in
2039 char * /* Return local label name. */
2040 fb_label_name (long n
, /* We just saw "n:", "nf" or "nb" : n a number. */
2041 long augend
/* 0 for nb, 1 for n:, nf. */)
2044 /* Returned to caller, then copied. Used for created names ("4f"). */
2045 static char symbol_name_build
[24];
2048 char symbol_name_temporary
[20]; /* Build up a number, BACKWARDS. */
2052 know ((unsigned long) augend
<= 2 /* See mmix_fb_label. */);
2054 know ((unsigned long) augend
<= 1);
2056 p
= symbol_name_build
;
2057 #ifdef LOCAL_LABEL_PREFIX
2058 *p
++ = LOCAL_LABEL_PREFIX
;
2062 /* Next code just does sprintf( {}, "%d", n); */
2064 q
= symbol_name_temporary
;
2065 for (*q
++ = 0, i
= n
; i
; ++q
)
2070 while ((*p
= *--q
) != '\0')
2073 *p
++ = LOCAL_LABEL_CHAR
; /* ^B */
2075 /* Instance number. */
2076 q
= symbol_name_temporary
;
2077 for (*q
++ = 0, i
= fb_label_instance (n
) + augend
; i
; ++q
)
2082 while ((*p
++ = *--q
) != '\0');
2084 /* The label, as a '\0' ended string, starts at symbol_name_build. */
2085 return (symbol_name_build
);
2088 /* Decode name that may have been generated by foo_label_name() above.
2089 If the name wasn't generated by foo_label_name(), then return it
2090 unaltered. This is used for error messages. */
2093 decode_local_label_name (char *s
)
2096 char *symbol_decode
;
2098 int instance_number
;
2100 const char *message_format
;
2103 #ifdef LOCAL_LABEL_PREFIX
2104 if (s
[lindex
] == LOCAL_LABEL_PREFIX
)
2108 if (s
[lindex
] != 'L')
2111 for (label_number
= 0, p
= s
+ lindex
+ 1; ISDIGIT (*p
); ++p
)
2112 label_number
= (10 * label_number
) + *p
- '0';
2114 if (*p
== DOLLAR_LABEL_CHAR
)
2116 else if (*p
== LOCAL_LABEL_CHAR
)
2121 for (instance_number
= 0, p
++; ISDIGIT (*p
); ++p
)
2122 instance_number
= (10 * instance_number
) + *p
- '0';
2124 message_format
= _("\"%d\" (instance number %d of a %s label)");
2125 symbol_decode
= (char *) obstack_alloc (¬es
, strlen (message_format
) + 30);
2126 sprintf (symbol_decode
, message_format
, label_number
, instance_number
, type
);
2128 return symbol_decode
;
2131 /* Get the value of a symbol. */
2134 S_GET_VALUE (symbolS
*s
)
2136 if (s
->flags
.local_symbol
)
2137 return resolve_symbol_value (s
);
2139 if (!s
->flags
.resolved
)
2141 valueT val
= resolve_symbol_value (s
);
2145 if (S_IS_WEAKREFR (s
))
2146 return S_GET_VALUE (s
->x
->value
.X_add_symbol
);
2148 if (s
->x
->value
.X_op
!= O_constant
)
2150 if (! s
->flags
.resolved
2151 || s
->x
->value
.X_op
!= O_symbol
2152 || (S_IS_DEFINED (s
) && ! S_IS_COMMON (s
)))
2153 as_bad (_("attempt to get value of unresolved symbol `%s'"),
2156 return (valueT
) s
->x
->value
.X_add_number
;
2159 /* Set the value of a symbol. */
2162 S_SET_VALUE (symbolS
*s
, valueT val
)
2164 if (s
->flags
.local_symbol
)
2166 ((struct local_symbol
*) s
)->value
= val
;
2170 s
->x
->value
.X_op
= O_constant
;
2171 s
->x
->value
.X_add_number
= (offsetT
) val
;
2172 s
->x
->value
.X_unsigned
= 0;
2173 S_CLEAR_WEAKREFR (s
);
2177 copy_symbol_attributes (symbolS
*dest
, symbolS
*src
)
2179 if (dest
->flags
.local_symbol
)
2180 dest
= local_symbol_convert (dest
);
2181 if (src
->flags
.local_symbol
)
2182 src
= local_symbol_convert (src
);
2184 /* In an expression, transfer the settings of these flags.
2185 The user can override later, of course. */
2186 #define COPIED_SYMFLAGS (BSF_FUNCTION | BSF_OBJECT \
2187 | BSF_GNU_INDIRECT_FUNCTION)
2188 dest
->bsym
->flags
|= src
->bsym
->flags
& COPIED_SYMFLAGS
;
2190 #ifdef OBJ_COPY_SYMBOL_ATTRIBUTES
2191 OBJ_COPY_SYMBOL_ATTRIBUTES (dest
, src
);
2194 #ifdef TC_COPY_SYMBOL_ATTRIBUTES
2195 TC_COPY_SYMBOL_ATTRIBUTES (dest
, src
);
2200 S_IS_FUNCTION (symbolS
*s
)
2204 if (s
->flags
.local_symbol
)
2207 flags
= s
->bsym
->flags
;
2209 return (flags
& BSF_FUNCTION
) != 0;
2213 S_IS_EXTERNAL (symbolS
*s
)
2217 if (s
->flags
.local_symbol
)
2220 flags
= s
->bsym
->flags
;
2223 if ((flags
& BSF_LOCAL
) && (flags
& BSF_GLOBAL
))
2226 return (flags
& BSF_GLOBAL
) != 0;
2230 S_IS_WEAK (symbolS
*s
)
2232 if (s
->flags
.local_symbol
)
2234 /* Conceptually, a weakrefr is weak if the referenced symbol is. We
2235 could probably handle a WEAKREFR as always weak though. E.g., if
2236 the referenced symbol has lost its weak status, there's no reason
2237 to keep handling the weakrefr as if it was weak. */
2238 if (S_IS_WEAKREFR (s
))
2239 return S_IS_WEAK (s
->x
->value
.X_add_symbol
);
2240 return (s
->bsym
->flags
& BSF_WEAK
) != 0;
2244 S_IS_WEAKREFR (symbolS
*s
)
2246 if (s
->flags
.local_symbol
)
2248 return s
->flags
.weakrefr
!= 0;
2252 S_IS_WEAKREFD (symbolS
*s
)
2254 if (s
->flags
.local_symbol
)
2256 return s
->flags
.weakrefd
!= 0;
2260 S_IS_COMMON (symbolS
*s
)
2262 if (s
->flags
.local_symbol
)
2264 return bfd_is_com_section (s
->bsym
->section
);
2268 S_IS_DEFINED (symbolS
*s
)
2270 if (s
->flags
.local_symbol
)
2271 return ((struct local_symbol
*) s
)->section
!= undefined_section
;
2272 return s
->bsym
->section
!= undefined_section
;
2276 #ifndef EXTERN_FORCE_RELOC
2277 #define EXTERN_FORCE_RELOC IS_ELF
2280 /* Return true for symbols that should not be reduced to section
2281 symbols or eliminated from expressions, because they may be
2282 overridden by the linker. */
2284 S_FORCE_RELOC (symbolS
*s
, int strict
)
2287 if (s
->flags
.local_symbol
)
2288 sec
= ((struct local_symbol
*) s
)->section
;
2292 && ((s
->bsym
->flags
& BSF_WEAK
) != 0
2293 || (EXTERN_FORCE_RELOC
2294 && (s
->bsym
->flags
& BSF_GLOBAL
) != 0)))
2295 || (s
->bsym
->flags
& BSF_GNU_INDIRECT_FUNCTION
) != 0)
2297 sec
= s
->bsym
->section
;
2299 return bfd_is_und_section (sec
) || bfd_is_com_section (sec
);
2303 S_IS_DEBUG (symbolS
*s
)
2305 if (s
->flags
.local_symbol
)
2307 if (s
->bsym
->flags
& BSF_DEBUGGING
)
2313 S_IS_LOCAL (symbolS
*s
)
2318 if (s
->flags
.local_symbol
)
2321 flags
= s
->bsym
->flags
;
2324 if ((flags
& BSF_LOCAL
) && (flags
& BSF_GLOBAL
))
2327 if (bfd_asymbol_section (s
->bsym
) == reg_section
)
2330 if (flag_strip_local_absolute
2331 /* Keep BSF_FILE symbols in order to allow debuggers to identify
2332 the source file even when the object file is stripped. */
2333 && (flags
& (BSF_GLOBAL
| BSF_FILE
)) == 0
2334 && bfd_asymbol_section (s
->bsym
) == absolute_section
)
2337 name
= S_GET_NAME (s
);
2338 return (name
!= NULL
2340 && (strchr (name
, DOLLAR_LABEL_CHAR
)
2341 || strchr (name
, LOCAL_LABEL_CHAR
)
2342 #if FAKE_LABEL_CHAR != DOLLAR_LABEL_CHAR
2343 || strchr (name
, FAKE_LABEL_CHAR
)
2345 || TC_LABEL_IS_LOCAL (name
)
2346 || (! flag_keep_locals
2347 && (bfd_is_local_label (stdoutput
, s
->bsym
)
2350 && name
[1] == '?')))));
2354 S_IS_STABD (symbolS
*s
)
2356 return S_GET_NAME (s
) == 0;
2360 S_CAN_BE_REDEFINED (const symbolS
*s
)
2362 if (s
->flags
.local_symbol
)
2363 return (((struct local_symbol
*) s
)->frag
2364 == &predefined_address_frag
);
2365 /* Permit register names to be redefined. */
2366 return s
->bsym
->section
== reg_section
;
2370 S_IS_VOLATILE (const symbolS
*s
)
2372 if (s
->flags
.local_symbol
)
2374 return s
->flags
.volatil
;
2378 S_IS_FORWARD_REF (const symbolS
*s
)
2380 if (s
->flags
.local_symbol
)
2382 return s
->flags
.forward_ref
;
2386 S_GET_NAME (symbolS
*s
)
2392 S_GET_SEGMENT (symbolS
*s
)
2394 if (s
->flags
.local_symbol
)
2395 return ((struct local_symbol
*) s
)->section
;
2396 return s
->bsym
->section
;
2400 S_SET_SEGMENT (symbolS
*s
, segT seg
)
2402 if (s
->flags
.local_symbol
)
2404 ((struct local_symbol
*) s
)->section
= seg
;
2408 /* Don't reassign section symbols. The direct reason is to prevent seg
2409 faults assigning back to const global symbols such as *ABS*, but it
2410 shouldn't happen anyway. */
2411 if (s
->bsym
->flags
& BSF_SECTION_SYM
)
2413 if (s
->bsym
->section
!= seg
)
2417 s
->bsym
->section
= seg
;
2421 S_SET_EXTERNAL (symbolS
*s
)
2423 if (s
->flags
.local_symbol
)
2424 s
= local_symbol_convert (s
);
2425 if ((s
->bsym
->flags
& BSF_WEAK
) != 0)
2427 /* Let .weak override .global. */
2430 if (s
->bsym
->flags
& BSF_SECTION_SYM
)
2432 /* Do not reassign section symbols. */
2433 as_warn (_("section symbols are already global"));
2436 #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
2437 if (S_GET_SEGMENT (s
) == reg_section
)
2439 as_bad ("can't make register symbol `%s' global",
2444 s
->bsym
->flags
|= BSF_GLOBAL
;
2445 s
->bsym
->flags
&= ~(BSF_LOCAL
| BSF_WEAK
);
2448 if (! an_external_name
&& S_GET_NAME(s
)[0] != '.')
2449 an_external_name
= S_GET_NAME (s
);
2454 S_CLEAR_EXTERNAL (symbolS
*s
)
2456 if (s
->flags
.local_symbol
)
2458 if ((s
->bsym
->flags
& BSF_WEAK
) != 0)
2460 /* Let .weak override. */
2463 s
->bsym
->flags
|= BSF_LOCAL
;
2464 s
->bsym
->flags
&= ~(BSF_GLOBAL
| BSF_WEAK
);
2468 S_SET_WEAK (symbolS
*s
)
2470 if (s
->flags
.local_symbol
)
2471 s
= local_symbol_convert (s
);
2472 #ifdef obj_set_weak_hook
2473 obj_set_weak_hook (s
);
2475 s
->bsym
->flags
|= BSF_WEAK
;
2476 s
->bsym
->flags
&= ~(BSF_GLOBAL
| BSF_LOCAL
);
2480 S_SET_WEAKREFR (symbolS
*s
)
2482 if (s
->flags
.local_symbol
)
2483 s
= local_symbol_convert (s
);
2484 s
->flags
.weakrefr
= 1;
2485 /* If the alias was already used, make sure we mark the target as
2486 used as well, otherwise it might be dropped from the symbol
2487 table. This may have unintended side effects if the alias is
2488 later redirected to another symbol, such as keeping the unused
2489 previous target in the symbol table. Since it will be weak, it's
2492 symbol_mark_used (s
->x
->value
.X_add_symbol
);
2496 S_CLEAR_WEAKREFR (symbolS
*s
)
2498 if (s
->flags
.local_symbol
)
2500 s
->flags
.weakrefr
= 0;
2504 S_SET_WEAKREFD (symbolS
*s
)
2506 if (s
->flags
.local_symbol
)
2507 s
= local_symbol_convert (s
);
2508 s
->flags
.weakrefd
= 1;
2513 S_CLEAR_WEAKREFD (symbolS
*s
)
2515 if (s
->flags
.local_symbol
)
2517 if (s
->flags
.weakrefd
)
2519 s
->flags
.weakrefd
= 0;
2520 /* If a weakref target symbol is weak, then it was never
2521 referenced directly before, not even in a .global directive,
2522 so decay it to local. If it remains undefined, it will be
2523 later turned into a global, like any other undefined
2525 if (s
->bsym
->flags
& BSF_WEAK
)
2527 #ifdef obj_clear_weak_hook
2528 obj_clear_weak_hook (s
);
2530 s
->bsym
->flags
&= ~BSF_WEAK
;
2531 s
->bsym
->flags
|= BSF_LOCAL
;
2537 S_SET_THREAD_LOCAL (symbolS
*s
)
2539 if (s
->flags
.local_symbol
)
2540 s
= local_symbol_convert (s
);
2541 if (bfd_is_com_section (s
->bsym
->section
)
2542 && (s
->bsym
->flags
& BSF_THREAD_LOCAL
) != 0)
2544 s
->bsym
->flags
|= BSF_THREAD_LOCAL
;
2545 if ((s
->bsym
->flags
& BSF_FUNCTION
) != 0)
2546 as_bad (_("Accessing function `%s' as thread-local object"),
2548 else if (! bfd_is_und_section (s
->bsym
->section
)
2549 && (s
->bsym
->section
->flags
& SEC_THREAD_LOCAL
) == 0)
2550 as_bad (_("Accessing `%s' as thread-local object"),
2555 S_SET_NAME (symbolS
*s
, const char *name
)
2558 if (s
->flags
.local_symbol
)
2560 s
->bsym
->name
= name
;
2564 S_SET_VOLATILE (symbolS
*s
)
2566 if (s
->flags
.local_symbol
)
2567 s
= local_symbol_convert (s
);
2568 s
->flags
.volatil
= 1;
2572 S_CLEAR_VOLATILE (symbolS
*s
)
2574 if (!s
->flags
.local_symbol
)
2575 s
->flags
.volatil
= 0;
2579 S_SET_FORWARD_REF (symbolS
*s
)
2581 if (s
->flags
.local_symbol
)
2582 s
= local_symbol_convert (s
);
2583 s
->flags
.forward_ref
= 1;
2586 /* Return the previous symbol in a chain. */
2589 symbol_previous (symbolS
*s
)
2591 if (s
->flags
.local_symbol
)
2593 return s
->x
->previous
;
2596 /* Return the next symbol in a chain. */
2599 symbol_next (symbolS
*s
)
2601 if (s
->flags
.local_symbol
)
2606 /* Return a pointer to the value of a symbol as an expression. */
2609 symbol_get_value_expression (symbolS
*s
)
2611 if (s
->flags
.local_symbol
)
2612 s
= local_symbol_convert (s
);
2613 return &s
->x
->value
;
2616 /* Set the value of a symbol to an expression. */
2619 symbol_set_value_expression (symbolS
*s
, const expressionS
*exp
)
2621 if (s
->flags
.local_symbol
)
2622 s
= local_symbol_convert (s
);
2624 S_CLEAR_WEAKREFR (s
);
2627 /* Return whether 2 symbols are the same. */
2630 symbol_same_p (symbolS
*s1
, symbolS
*s2
)
2635 /* Return a pointer to the X_add_number component of a symbol. */
2638 symbol_X_add_number (symbolS
*s
)
2640 if (s
->flags
.local_symbol
)
2641 return (offsetT
*) &((struct local_symbol
*) s
)->value
;
2643 return &s
->x
->value
.X_add_number
;
2646 /* Set the value of SYM to the current position in the current segment. */
2649 symbol_set_value_now (symbolS
*sym
)
2651 S_SET_SEGMENT (sym
, now_seg
);
2652 S_SET_VALUE (sym
, frag_now_fix ());
2653 symbol_set_frag (sym
, frag_now
);
2656 /* Set the frag of a symbol. */
2659 symbol_set_frag (symbolS
*s
, fragS
*f
)
2661 if (s
->flags
.local_symbol
)
2663 ((struct local_symbol
*) s
)->frag
= f
;
2667 S_CLEAR_WEAKREFR (s
);
2670 /* Return the frag of a symbol. */
2673 symbol_get_frag (symbolS
*s
)
2675 if (s
->flags
.local_symbol
)
2676 return ((struct local_symbol
*) s
)->frag
;
2680 /* Mark a symbol as having been used. */
2683 symbol_mark_used (symbolS
*s
)
2685 if (s
->flags
.local_symbol
)
2688 if (S_IS_WEAKREFR (s
))
2689 symbol_mark_used (s
->x
->value
.X_add_symbol
);
2692 /* Clear the mark of whether a symbol has been used. */
2695 symbol_clear_used (symbolS
*s
)
2697 if (s
->flags
.local_symbol
)
2698 s
= local_symbol_convert (s
);
2702 /* Return whether a symbol has been used. */
2705 symbol_used_p (symbolS
*s
)
2707 if (s
->flags
.local_symbol
)
2709 return s
->flags
.used
;
2712 /* Mark a symbol as having been used in a reloc. */
2715 symbol_mark_used_in_reloc (symbolS
*s
)
2717 if (s
->flags
.local_symbol
)
2718 s
= local_symbol_convert (s
);
2719 s
->flags
.used_in_reloc
= 1;
2722 /* Clear the mark of whether a symbol has been used in a reloc. */
2725 symbol_clear_used_in_reloc (symbolS
*s
)
2727 if (s
->flags
.local_symbol
)
2729 s
->flags
.used_in_reloc
= 0;
2732 /* Return whether a symbol has been used in a reloc. */
2735 symbol_used_in_reloc_p (symbolS
*s
)
2737 if (s
->flags
.local_symbol
)
2739 return s
->flags
.used_in_reloc
;
2742 /* Mark a symbol as an MRI common symbol. */
2745 symbol_mark_mri_common (symbolS
*s
)
2747 if (s
->flags
.local_symbol
)
2748 s
= local_symbol_convert (s
);
2749 s
->flags
.mri_common
= 1;
2752 /* Clear the mark of whether a symbol is an MRI common symbol. */
2755 symbol_clear_mri_common (symbolS
*s
)
2757 if (s
->flags
.local_symbol
)
2759 s
->flags
.mri_common
= 0;
2762 /* Return whether a symbol is an MRI common symbol. */
2765 symbol_mri_common_p (symbolS
*s
)
2767 if (s
->flags
.local_symbol
)
2769 return s
->flags
.mri_common
;
2772 /* Mark a symbol as having been written. */
2775 symbol_mark_written (symbolS
*s
)
2777 if (s
->flags
.local_symbol
)
2779 s
->flags
.written
= 1;
2782 /* Clear the mark of whether a symbol has been written. */
2785 symbol_clear_written (symbolS
*s
)
2787 if (s
->flags
.local_symbol
)
2789 s
->flags
.written
= 0;
2792 /* Return whether a symbol has been written. */
2795 symbol_written_p (symbolS
*s
)
2797 if (s
->flags
.local_symbol
)
2799 return s
->flags
.written
;
2802 /* Mark a symbol has having been resolved. */
2805 symbol_mark_resolved (symbolS
*s
)
2807 s
->flags
.resolved
= 1;
2810 /* Return whether a symbol has been resolved. */
2813 symbol_resolved_p (symbolS
*s
)
2815 return s
->flags
.resolved
;
2818 /* Return whether a symbol is a section symbol. */
2821 symbol_section_p (symbolS
*s
)
2823 if (s
->flags
.local_symbol
)
2825 return (s
->bsym
->flags
& BSF_SECTION_SYM
) != 0;
2828 /* Return whether a symbol is equated to another symbol. */
2831 symbol_equated_p (symbolS
*s
)
2833 if (s
->flags
.local_symbol
)
2835 return s
->x
->value
.X_op
== O_symbol
;
2838 /* Return whether a symbol is equated to another symbol, and should be
2839 treated specially when writing out relocs. */
2842 symbol_equated_reloc_p (symbolS
*s
)
2844 if (s
->flags
.local_symbol
)
2846 /* X_op_symbol, normally not used for O_symbol, is set by
2847 resolve_symbol_value to flag expression syms that have been
2849 return (s
->x
->value
.X_op
== O_symbol
2850 #if defined (OBJ_COFF) && defined (TE_PE)
2853 && ((s
->flags
.resolved
&& s
->x
->value
.X_op_symbol
!= NULL
)
2854 || ! S_IS_DEFINED (s
)
2855 || S_IS_COMMON (s
)));
2858 /* Return whether a symbol has a constant value. */
2861 symbol_constant_p (symbolS
*s
)
2863 if (s
->flags
.local_symbol
)
2865 return s
->x
->value
.X_op
== O_constant
;
2868 /* Return whether a symbol was cloned and thus removed from the global
2872 symbol_shadow_p (symbolS
*s
)
2874 if (s
->flags
.local_symbol
)
2876 return s
->x
->next
== s
;
2879 /* If S is a struct symbol return S, otherwise return NULL. */
2882 symbol_symbolS (symbolS
*s
)
2884 if (s
->flags
.local_symbol
)
2889 /* Return the BFD symbol for a symbol. */
2892 symbol_get_bfdsym (symbolS
*s
)
2894 if (s
->flags
.local_symbol
)
2895 s
= local_symbol_convert (s
);
2899 /* Set the BFD symbol for a symbol. */
2902 symbol_set_bfdsym (symbolS
*s
, asymbol
*bsym
)
2904 if (s
->flags
.local_symbol
)
2905 s
= local_symbol_convert (s
);
2906 /* Usually, it is harmless to reset a symbol to a BFD section
2907 symbol. For example, obj_elf_change_section sets the BFD symbol
2908 of an old symbol with the newly created section symbol. But when
2909 we have multiple sections with the same name, the newly created
2910 section may have the same name as an old section. We check if the
2911 old symbol has been already marked as a section symbol before
2913 if ((s
->bsym
->flags
& BSF_SECTION_SYM
) == 0)
2915 /* else XXX - What do we do now ? */
2918 #ifdef OBJ_SYMFIELD_TYPE
2920 /* Get a pointer to the object format information for a symbol. */
2923 symbol_get_obj (symbolS
*s
)
2925 if (s
->flags
.local_symbol
)
2926 s
= local_symbol_convert (s
);
2930 /* Set the object format information for a symbol. */
2933 symbol_set_obj (symbolS
*s
, OBJ_SYMFIELD_TYPE
*o
)
2935 if (s
->flags
.local_symbol
)
2936 s
= local_symbol_convert (s
);
2940 #endif /* OBJ_SYMFIELD_TYPE */
2942 #ifdef TC_SYMFIELD_TYPE
2944 /* Get a pointer to the processor information for a symbol. */
2947 symbol_get_tc (symbolS
*s
)
2949 if (s
->flags
.local_symbol
)
2950 s
= local_symbol_convert (s
);
2954 /* Set the processor information for a symbol. */
2957 symbol_set_tc (symbolS
*s
, TC_SYMFIELD_TYPE
*o
)
2959 if (s
->flags
.local_symbol
)
2960 s
= local_symbol_convert (s
);
2964 #endif /* TC_SYMFIELD_TYPE */
2969 symbol_lastP
= NULL
;
2970 symbol_rootP
= NULL
; /* In case we have 0 symbols (!!) */
2971 sy_hash
= htab_create_alloc (16, hash_symbol_entry
, eq_symbol_entry
,
2972 NULL
, xcalloc
, free
);
2974 #if defined (EMIT_SECTION_SYMBOLS) || !defined (RELOC_REQUIRES_SYMBOL)
2975 abs_symbol
.bsym
= bfd_abs_section_ptr
->symbol
;
2977 abs_symbol
.x
= &abs_symbol_x
;
2978 abs_symbol
.x
->value
.X_op
= O_constant
;
2979 abs_symbol
.frag
= &zero_address_frag
;
2981 if (LOCAL_LABELS_FB
)
2986 dot_symbol_init (void)
2988 dot_symbol
.name
= ".";
2989 dot_symbol
.flags
.forward_ref
= 1;
2990 dot_symbol
.bsym
= bfd_make_empty_symbol (stdoutput
);
2991 if (dot_symbol
.bsym
== NULL
)
2992 as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));
2993 dot_symbol
.bsym
->name
= ".";
2994 dot_symbol
.x
= &dot_symbol_x
;
2995 dot_symbol
.x
->value
.X_op
= O_constant
;
3000 /* Maximum indent level.
3001 Available for modification inside a gdb session. */
3002 static int max_indent_level
= 8;
3005 print_symbol_value_1 (FILE *file
, symbolS
*sym
)
3007 const char *name
= S_GET_NAME (sym
);
3008 if (!name
|| !name
[0])
3010 fprintf (file
, "sym ");
3011 fprintf_vma (file
, (bfd_vma
) ((bfd_hostptr_t
) sym
));
3012 fprintf (file
, " %s", name
);
3014 if (sym
->flags
.local_symbol
)
3016 struct local_symbol
*locsym
= (struct local_symbol
*) sym
;
3018 if (locsym
->frag
!= &zero_address_frag
3019 && locsym
->frag
!= NULL
)
3021 fprintf (file
, " frag ");
3022 fprintf_vma (file
, (bfd_vma
) ((bfd_hostptr_t
) locsym
->frag
));
3024 if (locsym
->flags
.resolved
)
3025 fprintf (file
, " resolved");
3026 fprintf (file
, " local");
3030 if (sym
->frag
!= &zero_address_frag
)
3032 fprintf (file
, " frag ");
3033 fprintf_vma (file
, (bfd_vma
) ((bfd_hostptr_t
) sym
->frag
));
3035 if (sym
->flags
.written
)
3036 fprintf (file
, " written");
3037 if (sym
->flags
.resolved
)
3038 fprintf (file
, " resolved");
3039 else if (sym
->flags
.resolving
)
3040 fprintf (file
, " resolving");
3041 if (sym
->flags
.used_in_reloc
)
3042 fprintf (file
, " used-in-reloc");
3043 if (sym
->flags
.used
)
3044 fprintf (file
, " used");
3045 if (S_IS_LOCAL (sym
))
3046 fprintf (file
, " local");
3047 if (S_IS_EXTERNAL (sym
))
3048 fprintf (file
, " extern");
3049 if (S_IS_WEAK (sym
))
3050 fprintf (file
, " weak");
3051 if (S_IS_DEBUG (sym
))
3052 fprintf (file
, " debug");
3053 if (S_IS_DEFINED (sym
))
3054 fprintf (file
, " defined");
3056 if (S_IS_WEAKREFR (sym
))
3057 fprintf (file
, " weakrefr");
3058 if (S_IS_WEAKREFD (sym
))
3059 fprintf (file
, " weakrefd");
3060 fprintf (file
, " %s", segment_name (S_GET_SEGMENT (sym
)));
3061 if (symbol_resolved_p (sym
))
3063 segT s
= S_GET_SEGMENT (sym
);
3065 if (s
!= undefined_section
3066 && s
!= expr_section
)
3067 fprintf (file
, " %lx", (unsigned long) S_GET_VALUE (sym
));
3069 else if (indent_level
< max_indent_level
3070 && S_GET_SEGMENT (sym
) != undefined_section
)
3073 fprintf (file
, "\n%*s<", indent_level
* 4, "");
3074 if (sym
->flags
.local_symbol
)
3075 fprintf (file
, "constant %lx",
3076 (unsigned long) ((struct local_symbol
*) sym
)->value
);
3078 print_expr_1 (file
, &sym
->x
->value
);
3079 fprintf (file
, ">");
3086 print_symbol_value (symbolS
*sym
)
3089 print_symbol_value_1 (stderr
, sym
);
3090 fprintf (stderr
, "\n");
3094 print_binary (FILE *file
, const char *name
, expressionS
*exp
)
3097 fprintf (file
, "%s\n%*s<", name
, indent_level
* 4, "");
3098 print_symbol_value_1 (file
, exp
->X_add_symbol
);
3099 fprintf (file
, ">\n%*s<", indent_level
* 4, "");
3100 print_symbol_value_1 (file
, exp
->X_op_symbol
);
3101 fprintf (file
, ">");
3106 print_expr_1 (FILE *file
, expressionS
*exp
)
3108 fprintf (file
, "expr ");
3109 fprintf_vma (file
, (bfd_vma
) ((bfd_hostptr_t
) exp
));
3110 fprintf (file
, " ");
3114 fprintf (file
, "illegal");
3117 fprintf (file
, "absent");
3120 fprintf (file
, "constant %lx", (unsigned long) exp
->X_add_number
);
3124 fprintf (file
, "symbol\n%*s<", indent_level
* 4, "");
3125 print_symbol_value_1 (file
, exp
->X_add_symbol
);
3126 fprintf (file
, ">");
3128 if (exp
->X_add_number
)
3129 fprintf (file
, "\n%*s%lx", indent_level
* 4, "",
3130 (unsigned long) exp
->X_add_number
);
3134 fprintf (file
, "register #%d", (int) exp
->X_add_number
);
3137 fprintf (file
, "big");
3140 fprintf (file
, "uminus -<");
3142 print_symbol_value_1 (file
, exp
->X_add_symbol
);
3143 fprintf (file
, ">");
3144 goto maybe_print_addnum
;
3146 fprintf (file
, "bit_not");
3149 print_binary (file
, "multiply", exp
);
3152 print_binary (file
, "divide", exp
);
3155 print_binary (file
, "modulus", exp
);
3158 print_binary (file
, "lshift", exp
);
3161 print_binary (file
, "rshift", exp
);
3163 case O_bit_inclusive_or
:
3164 print_binary (file
, "bit_ior", exp
);
3166 case O_bit_exclusive_or
:
3167 print_binary (file
, "bit_xor", exp
);
3170 print_binary (file
, "bit_and", exp
);
3173 print_binary (file
, "eq", exp
);
3176 print_binary (file
, "ne", exp
);
3179 print_binary (file
, "lt", exp
);
3182 print_binary (file
, "le", exp
);
3185 print_binary (file
, "ge", exp
);
3188 print_binary (file
, "gt", exp
);
3191 print_binary (file
, "logical_and", exp
);
3194 print_binary (file
, "logical_or", exp
);
3198 fprintf (file
, "add\n%*s<", indent_level
* 4, "");
3199 print_symbol_value_1 (file
, exp
->X_add_symbol
);
3200 fprintf (file
, ">\n%*s<", indent_level
* 4, "");
3201 print_symbol_value_1 (file
, exp
->X_op_symbol
);
3202 fprintf (file
, ">");
3203 goto maybe_print_addnum
;
3206 fprintf (file
, "subtract\n%*s<", indent_level
* 4, "");
3207 print_symbol_value_1 (file
, exp
->X_add_symbol
);
3208 fprintf (file
, ">\n%*s<", indent_level
* 4, "");
3209 print_symbol_value_1 (file
, exp
->X_op_symbol
);
3210 fprintf (file
, ">");
3211 goto maybe_print_addnum
;
3213 fprintf (file
, "{unknown opcode %d}", (int) exp
->X_op
);
3220 print_expr (expressionS
*exp
)
3222 print_expr_1 (stderr
, exp
);
3223 fprintf (stderr
, "\n");
3227 symbol_print_statistics (FILE *file
)
3229 htab_print_statistics (file
, "symbol table", sy_hash
);
3230 fprintf (file
, "%lu mini local symbols created, %lu converted\n",
3231 local_symbol_count
, local_symbol_conversion_count
);
3234 #ifdef OBJ_COMPLEX_RELC
3236 /* Convert given symbol to a new complex-relocation symbol name. This
3237 may be a recursive function, since it might be called for non-leaf
3238 nodes (plain symbols) in the expression tree. The caller owns the
3239 returning string, so should free it eventually. Errors are
3240 indicated via as_bad and a NULL return value. The given symbol
3241 is marked with used_in_reloc. */
3244 symbol_relc_make_sym (symbolS
* sym
)
3246 char * terminal
= NULL
;
3251 gas_assert (sym
!= NULL
);
3253 /* Recurse to symbol_relc_make_expr if this symbol
3254 is defined as an expression or a plain value. */
3255 if ( S_GET_SEGMENT (sym
) == expr_section
3256 || S_GET_SEGMENT (sym
) == absolute_section
)
3257 return symbol_relc_make_expr (symbol_get_value_expression (sym
));
3259 /* This may be a "fake symbol", referring to ".".
3260 Write out a special null symbol to refer to this position. */
3261 if (! strcmp (S_GET_NAME (sym
), FAKE_LABEL_NAME
))
3262 return xstrdup (".");
3264 /* We hope this is a plain leaf symbol. Construct the encoding
3265 as {S,s}II...:CCCCCCC....
3266 where 'S'/'s' means section symbol / plain symbol
3267 III is decimal for the symbol name length
3268 CCC is the symbol name itself. */
3269 symbol_mark_used_in_reloc (sym
);
3271 sname
= S_GET_NAME (sym
);
3272 sname_len
= strlen (sname
);
3273 typetag
= symbol_section_p (sym
) ? 'S' : 's';
3275 terminal
= XNEWVEC (char, (1 /* S or s */
3276 + 8 /* sname_len in decimal */
3278 + sname_len
/* name itself */
3281 sprintf (terminal
, "%c%d:%s", typetag
, sname_len
, sname
);
3285 /* Convert given value to a new complex-relocation symbol name. This
3286 is a non-recursive function, since it is be called for leaf nodes
3287 (plain values) in the expression tree. The caller owns the
3288 returning string, so should free() it eventually. No errors. */
3291 symbol_relc_make_value (offsetT val
)
3293 char * terminal
= XNEWVEC (char, 28); /* Enough for long long. */
3296 bfd_sprintf_vma (stdoutput
, terminal
+ 1, val
);
3300 /* Convert given expression to a new complex-relocation symbol name.
3301 This is a recursive function, since it traverses the entire given
3302 expression tree. The caller owns the returning string, so should
3303 free() it eventually. Errors are indicated via as_bad() and a NULL
3307 symbol_relc_make_expr (expressionS
* exp
)
3309 const char * opstr
= NULL
; /* Operator prefix string. */
3310 int arity
= 0; /* Arity of this operator. */
3311 char * operands
[3]; /* Up to three operands. */
3312 char * concat_string
= NULL
;
3314 operands
[0] = operands
[1] = operands
[2] = NULL
;
3316 gas_assert (exp
!= NULL
);
3318 /* Match known operators -> fill in opstr, arity, operands[] and fall
3319 through to construct subexpression fragments; may instead return
3320 string directly for leaf nodes. */
3322 /* See expr.h for the meaning of all these enums. Many operators
3323 have an unnatural arity (X_add_number implicitly added). The
3324 conversion logic expands them to explicit "+" subexpressions. */
3329 as_bad ("Unknown expression operator (enum %d)", exp
->X_op
);
3334 return symbol_relc_make_value (exp
->X_add_number
);
3337 if (exp
->X_add_number
)
3341 operands
[0] = symbol_relc_make_sym (exp
->X_add_symbol
);
3342 operands
[1] = symbol_relc_make_value (exp
->X_add_number
);
3346 return symbol_relc_make_sym (exp
->X_add_symbol
);
3348 /* Helper macros for nesting nodes. */
3350 #define HANDLE_XADD_OPT1(str_) \
3351 if (exp->X_add_number) \
3354 opstr = "+:" str_; \
3355 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3356 operands[1] = symbol_relc_make_value (exp->X_add_number); \
3363 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3367 #define HANDLE_XADD_OPT2(str_) \
3368 if (exp->X_add_number) \
3371 opstr = "+:" str_; \
3372 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3373 operands[1] = symbol_relc_make_sym (exp->X_op_symbol); \
3374 operands[2] = symbol_relc_make_value (exp->X_add_number); \
3380 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3381 operands[1] = symbol_relc_make_sym (exp->X_op_symbol); \
3385 /* Nesting nodes. */
3387 case O_uminus
: HANDLE_XADD_OPT1 ("0-");
3388 case O_bit_not
: HANDLE_XADD_OPT1 ("~");
3389 case O_logical_not
: HANDLE_XADD_OPT1 ("!");
3390 case O_multiply
: HANDLE_XADD_OPT2 ("*");
3391 case O_divide
: HANDLE_XADD_OPT2 ("/");
3392 case O_modulus
: HANDLE_XADD_OPT2 ("%");
3393 case O_left_shift
: HANDLE_XADD_OPT2 ("<<");
3394 case O_right_shift
: HANDLE_XADD_OPT2 (">>");
3395 case O_bit_inclusive_or
: HANDLE_XADD_OPT2 ("|");
3396 case O_bit_exclusive_or
: HANDLE_XADD_OPT2 ("^");
3397 case O_bit_and
: HANDLE_XADD_OPT2 ("&");
3398 case O_add
: HANDLE_XADD_OPT2 ("+");
3399 case O_subtract
: HANDLE_XADD_OPT2 ("-");
3400 case O_eq
: HANDLE_XADD_OPT2 ("==");
3401 case O_ne
: HANDLE_XADD_OPT2 ("!=");
3402 case O_lt
: HANDLE_XADD_OPT2 ("<");
3403 case O_le
: HANDLE_XADD_OPT2 ("<=");
3404 case O_ge
: HANDLE_XADD_OPT2 (">=");
3405 case O_gt
: HANDLE_XADD_OPT2 (">");
3406 case O_logical_and
: HANDLE_XADD_OPT2 ("&&");
3407 case O_logical_or
: HANDLE_XADD_OPT2 ("||");
3410 /* Validate & reject early. */
3411 if (arity
>= 1 && ((operands
[0] == NULL
) || (strlen (operands
[0]) == 0)))
3413 if (arity
>= 2 && ((operands
[1] == NULL
) || (strlen (operands
[1]) == 0)))
3415 if (arity
>= 3 && ((operands
[2] == NULL
) || (strlen (operands
[2]) == 0)))
3419 concat_string
= NULL
;
3420 else if (arity
== 0)
3421 concat_string
= xstrdup (opstr
);
3422 else if (arity
== 1)
3423 concat_string
= concat (opstr
, ":", operands
[0], (char *) NULL
);
3424 else if (arity
== 2)
3425 concat_string
= concat (opstr
, ":", operands
[0], ":", operands
[1],
3428 concat_string
= concat (opstr
, ":", operands
[0], ":", operands
[1], ":",
3429 operands
[2], (char *) NULL
);
3431 /* Free operand strings (not opstr). */
3432 if (arity
>= 1) xfree (operands
[0]);
3433 if (arity
>= 2) xfree (operands
[1]);
3434 if (arity
>= 3) xfree (operands
[2]);
3436 return concat_string
;