1 /* symbols.c -symbol table-
2 Copyright (C) 1987-2022 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" */
36 /* Whether the symbol is a local_symbol. */
37 unsigned int local_symbol
: 1;
39 /* Weather symbol has been written. */
40 unsigned int written
: 1;
42 /* Whether symbol value has been completely resolved (used during
43 final pass over symbol table). */
44 unsigned int resolved
: 1;
46 /* Whether the symbol value is currently being resolved (used to
47 detect loops in symbol dependencies). */
48 unsigned int resolving
: 1;
50 /* Whether the symbol value is used in a reloc. This is used to
51 ensure that symbols used in relocs are written out, even if they
52 are local and would otherwise not be. */
53 unsigned int used_in_reloc
: 1;
55 /* Whether the symbol is used as an operand or in an expression.
56 NOTE: Not all the backends keep this information accurate;
57 backends which use this bit are responsible for setting it when
58 a symbol is used in backend routines. */
59 unsigned int used
: 1;
61 /* Whether the symbol can be re-defined. */
62 unsigned int volatil
: 1;
64 /* Whether the symbol is a forward reference, and whether such has
66 unsigned int forward_ref
: 1;
67 unsigned int forward_resolved
: 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;
84 /* Whether the symbol has been marked to be removed by a .symver
86 unsigned int removed
: 1;
88 /* Set when a warning about the symbol containing multibyte characters
90 unsigned int multibyte_warned
: 1;
93 /* A pointer in the symbol may point to either a complete symbol
94 (struct symbol below) or to a local symbol (struct local_symbol
95 defined here). The symbol code can detect the case by examining
96 the first field which is present in both structs.
98 We do this because we ordinarily only need a small amount of
99 information for a local symbol. The symbol table takes up a lot of
100 space, and storing less information for a local symbol can make a
101 big difference in assembler memory usage when assembling a large
106 /* Symbol flags. Only local_symbol and resolved are relevant. */
107 struct symbol_flags flags
;
109 /* Hash value calculated from name. */
112 /* The symbol name. */
115 /* The symbol frag. */
118 /* The symbol section. */
121 /* The value of the symbol. */
125 /* The information we keep for a symbol. The symbol table holds
126 pointers both to this and to local_symbol structures. The first
127 three fields must be identical to struct local_symbol, and the size
128 should be the same as or smaller than struct local_symbol.
129 Fields that don't fit go to an extension structure. */
134 struct symbol_flags flags
;
136 /* Hash value calculated from name. */
139 /* The symbol name. */
142 /* Pointer to the frag this symbol is attached to, if any.
149 /* Extra symbol fields that won't fit. */
153 /* Extra fields to make up a full symbol. */
157 /* The value of the symbol. */
160 /* Forwards and backwards chain pointers. */
162 struct symbol
*previous
;
164 #ifdef OBJ_SYMFIELD_TYPE
165 OBJ_SYMFIELD_TYPE obj
;
168 #ifdef TC_SYMFIELD_TYPE
173 typedef union symbol_entry
175 struct local_symbol lsy
;
179 /* Hash function for a symbol_entry. */
182 hash_symbol_entry (const void *e
)
184 symbol_entry_t
*entry
= (symbol_entry_t
*) e
;
185 if (entry
->sy
.hash
== 0)
186 entry
->sy
.hash
= htab_hash_string (entry
->sy
.name
);
188 return entry
->sy
.hash
;
191 /* Equality function for a symbol_entry. */
194 eq_symbol_entry (const void *a
, const void *b
)
196 const symbol_entry_t
*ea
= (const symbol_entry_t
*) a
;
197 const symbol_entry_t
*eb
= (const symbol_entry_t
*) b
;
199 return (ea
->sy
.hash
== eb
->sy
.hash
200 && strcmp (ea
->sy
.name
, eb
->sy
.name
) == 0);
204 symbol_entry_find (htab_t table
, const char *name
)
206 hashval_t hash
= htab_hash_string (name
);
207 symbol_entry_t needle
= { { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
208 hash
, name
, 0, 0, 0 } };
209 return htab_find_with_hash (table
, &needle
, hash
);
213 /* This is non-zero if symbols are case sensitive, which is the
215 int symbols_case_sensitive
= 1;
217 #ifndef WORKING_DOT_WORD
218 extern int new_broken_words
;
221 static htab_t sy_hash
;
223 /* Below are commented in "symbols.h". */
224 symbolS
*symbol_rootP
;
225 symbolS
*symbol_lastP
;
227 struct xsymbol abs_symbol_x
;
229 struct xsymbol dot_symbol_x
;
232 #define debug_verify_symchain verify_symbol_chain
234 #define debug_verify_symchain(root, last) ((void) 0)
237 #define DOLLAR_LABEL_CHAR '\001'
238 #define LOCAL_LABEL_CHAR '\002'
240 #ifndef TC_LABEL_IS_LOCAL
241 #define TC_LABEL_IS_LOCAL(name) 0
244 struct obstack notes
;
246 /* Utility functions to allocate and duplicate memory on the notes
247 obstack, each like the corresponding function without "notes_"
248 prefix. All of these exit on an allocation failure. */
251 notes_alloc (size_t size
)
253 return obstack_alloc (¬es
, size
);
257 notes_calloc (size_t n
, size_t size
)
261 if (gas_mul_overflow (n
, size
, &amt
))
263 obstack_alloc_failed_handler ();
266 ret
= notes_alloc (amt
);
267 memset (ret
, 0, amt
);
272 notes_memdup (const void *src
, size_t copy_size
, size_t alloc_size
)
274 void *ret
= obstack_alloc (¬es
, alloc_size
);
275 memcpy (ret
, src
, copy_size
);
276 if (alloc_size
> copy_size
)
277 memset ((char *) ret
+ copy_size
, 0, alloc_size
- copy_size
);
282 notes_strdup (const char *str
)
284 size_t len
= strlen (str
) + 1;
285 return notes_memdup (str
, len
, len
);
289 notes_concat (const char *first
, ...)
294 va_start (args
, first
);
295 for (str
= first
; str
; str
= va_arg (args
, const char *))
297 size_t size
= strlen (str
);
298 obstack_grow (¬es
, str
, size
);
301 obstack_1grow (¬es
, 0);
302 return obstack_finish (¬es
);
305 /* Use with caution! Frees PTR and all more recently allocated memory
306 on the notes obstack. */
309 notes_free (void *ptr
)
311 obstack_free (¬es
, ptr
);
315 /* The name of an external symbol which is
316 used to make weak PE symbol names unique. */
317 const char * an_external_name
;
320 /* Return a pointer to a new symbol. Die if we can't make a new
321 symbol. Fill in the symbol's values. Add symbol to end of symbol
324 This function should be called in the general case of creating a
325 symbol. However, if the output file symbol table has already been
326 set, and you are certain that this symbol won't be wanted in the
327 output file, you can call symbol_create. */
330 symbol_new (const char *name
, segT segment
, fragS
*frag
, valueT valu
)
332 symbolS
*symbolP
= symbol_create (name
, segment
, frag
, valu
);
334 /* Link to end of symbol chain. */
335 symbol_append (symbolP
, symbol_lastP
, &symbol_rootP
, &symbol_lastP
);
340 /* Save a symbol name on a permanent obstack, and convert it according
341 to the object file format. */
344 save_symbol_name (const char *name
)
348 gas_assert (name
!= NULL
);
349 ret
= notes_strdup (name
);
351 #ifdef tc_canonicalize_symbol_name
352 ret
= tc_canonicalize_symbol_name (ret
);
355 if (! symbols_case_sensitive
)
359 for (s
= ret
; *s
!= '\0'; s
++)
367 symbol_init (symbolS
*symbolP
, const char *name
, asection
*sec
,
368 fragS
*frag
, valueT valu
)
370 symbolP
->frag
= frag
;
371 symbolP
->bsym
= bfd_make_empty_symbol (stdoutput
);
372 if (symbolP
->bsym
== NULL
)
373 as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));
374 symbolP
->bsym
->name
= name
;
375 symbolP
->bsym
->section
= sec
;
377 if (multibyte_handling
== multibyte_warn_syms
378 && ! symbolP
->flags
.local_symbol
379 && sec
!= undefined_section
380 && ! symbolP
->flags
.multibyte_warned
381 && scan_for_multibyte_characters ((const unsigned char *) name
,
382 (const unsigned char *) name
+ strlen (name
),
383 false /* Do not warn. */))
385 as_warn (_("symbol '%s' contains multibyte characters"), name
);
386 symbolP
->flags
.multibyte_warned
= 1;
389 S_SET_VALUE (symbolP
, valu
);
391 symbol_clear_list_pointers (symbolP
);
393 obj_symbol_new_hook (symbolP
);
395 #ifdef tc_symbol_new_hook
396 tc_symbol_new_hook (symbolP
);
400 /* Create a symbol. NAME is copied, the caller can destroy/modify. */
403 symbol_create (const char *name
, segT segment
, fragS
*frag
, valueT valu
)
405 const char *preserved_copy_of_name
;
409 preserved_copy_of_name
= save_symbol_name (name
);
411 size
= sizeof (symbolS
) + sizeof (struct xsymbol
);
412 symbolP
= notes_alloc (size
);
414 /* symbol must be born in some fixed state. This seems as good as any. */
415 memset (symbolP
, 0, size
);
416 symbolP
->name
= preserved_copy_of_name
;
417 symbolP
->x
= (struct xsymbol
*) (symbolP
+ 1);
419 symbol_init (symbolP
, preserved_copy_of_name
, segment
, frag
, valu
);
425 /* Local symbol support. If we can get away with it, we keep only a
426 small amount of information for local symbols. */
428 /* Used for statistics. */
430 static unsigned long local_symbol_count
;
431 static unsigned long local_symbol_conversion_count
;
433 /* Create a local symbol and insert it into the local hash table. */
435 struct local_symbol
*
436 local_symbol_make (const char *name
, segT section
, fragS
*frag
, valueT val
)
438 const char *name_copy
;
439 struct local_symbol
*ret
;
440 struct symbol_flags flags
= { .local_symbol
= 1, .resolved
= 0 };
442 ++local_symbol_count
;
444 name_copy
= save_symbol_name (name
);
446 ret
= notes_alloc (sizeof *ret
);
449 ret
->name
= name_copy
;
451 ret
->section
= section
;
454 htab_insert (sy_hash
, ret
, 1);
459 /* Convert a local symbol into a real symbol. */
462 local_symbol_convert (void *sym
)
464 symbol_entry_t
*ent
= (symbol_entry_t
*) sym
;
465 struct xsymbol
*xtra
;
468 gas_assert (ent
->lsy
.flags
.local_symbol
);
470 ++local_symbol_conversion_count
;
472 xtra
= notes_alloc (sizeof (*xtra
));
473 memset (xtra
, 0, sizeof (*xtra
));
474 val
= ent
->lsy
.value
;
477 /* Local symbols are always either defined or used. */
478 ent
->sy
.flags
.used
= 1;
479 ent
->sy
.flags
.local_symbol
= 0;
481 symbol_init (&ent
->sy
, ent
->lsy
.name
, ent
->lsy
.section
, ent
->lsy
.frag
, val
);
482 symbol_append (&ent
->sy
, symbol_lastP
, &symbol_rootP
, &symbol_lastP
);
488 define_sym_at_dot (symbolS
*symbolP
)
490 symbolP
->frag
= frag_now
;
491 S_SET_VALUE (symbolP
, (valueT
) frag_now_fix ());
492 S_SET_SEGMENT (symbolP
, now_seg
);
495 /* We have just seen "<name>:".
496 Creates a struct symbol unless it already exists.
498 Gripes if we are redefining a symbol incompatibly (and ignores it). */
501 colon (/* Just seen "x:" - rattle symbols & frags. */
502 const char *sym_name
/* Symbol name, as a canonical string. */
503 /* We copy this string: OK to alter later. */)
505 symbolS
*symbolP
; /* Symbol we are working with. */
507 /* Sun local labels go out of scope whenever a non-local symbol is
509 if (LOCAL_LABELS_DOLLAR
510 && !bfd_is_local_label_name (stdoutput
, sym_name
))
511 dollar_label_clear ();
513 #ifndef WORKING_DOT_WORD
514 if (new_broken_words
)
516 struct broken_word
*a
;
521 if (now_seg
== absolute_section
)
523 as_bad (_("cannot define symbol `%s' in absolute section"), sym_name
);
527 possible_bytes
= (md_short_jump_size
528 + new_broken_words
* md_long_jump_size
);
531 frag_opcode
= frag_var (rs_broken_word
,
535 (symbolS
*) broken_words
,
539 /* We want to store the pointer to where to insert the jump
540 table in the fr_opcode of the rs_broken_word frag. This
541 requires a little hackery. */
543 && (frag_tmp
->fr_type
!= rs_broken_word
544 || frag_tmp
->fr_opcode
))
545 frag_tmp
= frag_tmp
->fr_next
;
547 frag_tmp
->fr_opcode
= frag_opcode
;
548 new_broken_words
= 0;
550 for (a
= broken_words
; a
&& a
->dispfrag
== 0; a
= a
->next_broken_word
)
551 a
->dispfrag
= frag_tmp
;
553 #endif /* WORKING_DOT_WORD */
555 #ifdef obj_frob_colon
556 obj_frob_colon (sym_name
);
559 if ((symbolP
= symbol_find (sym_name
)) != 0)
561 S_CLEAR_WEAKREFR (symbolP
);
562 #ifdef RESOLVE_SYMBOL_REDEFINITION
563 if (RESOLVE_SYMBOL_REDEFINITION (symbolP
))
566 /* Now check for undefined symbols. */
567 if (symbolP
->flags
.local_symbol
)
569 struct local_symbol
*locsym
= (struct local_symbol
*) symbolP
;
571 if (locsym
->section
!= undefined_section
572 && (locsym
->frag
!= frag_now
573 || locsym
->section
!= now_seg
574 || locsym
->value
!= frag_now_fix ()))
576 as_bad (_("symbol `%s' is already defined"), sym_name
);
580 locsym
->section
= now_seg
;
581 locsym
->frag
= frag_now
;
582 locsym
->value
= frag_now_fix ();
584 else if (!(S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
585 || S_IS_COMMON (symbolP
)
586 || S_IS_VOLATILE (symbolP
))
588 if (S_IS_VOLATILE (symbolP
))
590 symbolP
= symbol_clone (symbolP
, 1);
591 S_SET_VALUE (symbolP
, 0);
592 S_CLEAR_VOLATILE (symbolP
);
594 if (S_GET_VALUE (symbolP
) == 0)
596 define_sym_at_dot (symbolP
);
599 #endif /* if we have one, it better be zero. */
604 /* There are still several cases to check:
606 A .comm/.lcomm symbol being redefined as initialized
609 A .comm/.lcomm symbol being redefined with a larger
612 This only used to be allowed on VMS gas, but Sun cc
613 on the sparc also depends on it. */
615 if (((!S_IS_DEBUG (symbolP
)
616 && (!S_IS_DEFINED (symbolP
) || S_IS_COMMON (symbolP
))
617 && S_IS_EXTERNAL (symbolP
))
618 || S_GET_SEGMENT (symbolP
) == bss_section
)
619 && (now_seg
== data_section
620 || now_seg
== bss_section
621 || now_seg
== S_GET_SEGMENT (symbolP
)))
623 /* Select which of the 2 cases this is. */
624 if (now_seg
!= data_section
)
626 /* New .comm for prev .comm symbol.
628 If the new size is larger we just change its
629 value. If the new size is smaller, we ignore
631 if (S_GET_VALUE (symbolP
)
632 < ((unsigned) frag_now_fix ()))
634 S_SET_VALUE (symbolP
, (valueT
) frag_now_fix ());
639 /* It is a .comm/.lcomm being converted to initialized
641 define_sym_at_dot (symbolP
);
646 #if (!defined (OBJ_AOUT) && !defined (OBJ_MAYBE_AOUT))
647 static const char *od_buf
= "";
651 if (OUTPUT_FLAVOR
== bfd_target_aout_flavour
)
652 sprintf (od_buf
, "%d.%d.",
653 S_GET_OTHER (symbolP
),
654 S_GET_DESC (symbolP
));
656 as_bad (_("symbol `%s' is already defined as \"%s\"/%s%ld"),
658 segment_name (S_GET_SEGMENT (symbolP
)),
660 (long) S_GET_VALUE (symbolP
));
662 } /* if the undefined symbol has no value */
666 /* Don't blow up if the definition is the same. */
667 if (!(frag_now
== symbolP
->frag
668 && S_GET_VALUE (symbolP
) == frag_now_fix ()
669 && S_GET_SEGMENT (symbolP
) == now_seg
))
671 as_bad (_("symbol `%s' is already defined"), sym_name
);
672 symbolP
= symbol_clone (symbolP
, 0);
673 define_sym_at_dot (symbolP
);
678 else if (! flag_keep_locals
&& bfd_is_local_label_name (stdoutput
, sym_name
))
680 symbolP
= (symbolS
*) local_symbol_make (sym_name
, now_seg
, frag_now
,
685 symbolP
= symbol_new (sym_name
, now_seg
, frag_now
, frag_now_fix ());
687 symbol_table_insert (symbolP
);
690 if (mri_common_symbol
!= NULL
)
692 /* This symbol is actually being defined within an MRI common
693 section. This requires special handling. */
694 if (symbolP
->flags
.local_symbol
)
695 symbolP
= local_symbol_convert (symbolP
);
696 symbolP
->x
->value
.X_op
= O_symbol
;
697 symbolP
->x
->value
.X_add_symbol
= mri_common_symbol
;
698 symbolP
->x
->value
.X_add_number
= S_GET_VALUE (mri_common_symbol
);
699 symbolP
->frag
= &zero_address_frag
;
700 S_SET_SEGMENT (symbolP
, expr_section
);
701 symbolP
->flags
.mri_common
= 1;
705 tc_frob_label (symbolP
);
707 #ifdef obj_frob_label
708 obj_frob_label (symbolP
);
714 /* Die if we can't insert the symbol. */
717 symbol_table_insert (symbolS
*symbolP
)
721 htab_insert (sy_hash
, symbolP
, 1);
724 /* If a symbol name does not exist, create it as undefined, and insert
725 it into the symbol table. Return a pointer to it. */
728 symbol_find_or_make (const char *name
)
732 symbolP
= symbol_find (name
);
736 if (! flag_keep_locals
&& bfd_is_local_label_name (stdoutput
, name
))
738 symbolP
= md_undefined_symbol ((char *) name
);
742 symbolP
= (symbolS
*) local_symbol_make (name
, undefined_section
,
743 &zero_address_frag
, 0);
747 symbolP
= symbol_make (name
);
749 symbol_table_insert (symbolP
);
750 } /* if symbol wasn't found */
756 symbol_make (const char *name
)
760 /* Let the machine description default it, e.g. for register names. */
761 symbolP
= md_undefined_symbol ((char *) name
);
764 symbolP
= symbol_new (name
, undefined_section
, &zero_address_frag
, 0);
770 symbol_clone (symbolS
*orgsymP
, int replace
)
773 asymbol
*bsymorg
, *bsymnew
;
775 /* Make sure we never clone the dot special symbol. */
776 gas_assert (orgsymP
!= &dot_symbol
);
778 /* When cloning a local symbol it isn't absolutely necessary to
779 convert the original, but converting makes the code much
780 simpler to cover this unexpected case. As of 2020-08-21
781 symbol_clone won't be called on a local symbol. */
782 if (orgsymP
->flags
.local_symbol
)
783 orgsymP
= local_symbol_convert (orgsymP
);
784 bsymorg
= orgsymP
->bsym
;
786 newsymP
= notes_alloc (sizeof (symbolS
) + sizeof (struct xsymbol
));
788 newsymP
->x
= (struct xsymbol
*) (newsymP
+ 1);
789 *newsymP
->x
= *orgsymP
->x
;
790 bsymnew
= bfd_make_empty_symbol (bfd_asymbol_bfd (bsymorg
));
792 as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));
793 newsymP
->bsym
= bsymnew
;
794 bsymnew
->name
= bsymorg
->name
;
795 bsymnew
->flags
= bsymorg
->flags
& ~BSF_SECTION_SYM
;
796 bsymnew
->section
= bsymorg
->section
;
797 bfd_copy_private_symbol_data (bfd_asymbol_bfd (bsymorg
), bsymorg
,
798 bfd_asymbol_bfd (bsymnew
), bsymnew
);
800 #ifdef obj_symbol_clone_hook
801 obj_symbol_clone_hook (newsymP
, orgsymP
);
804 #ifdef tc_symbol_clone_hook
805 tc_symbol_clone_hook (newsymP
, orgsymP
);
810 if (symbol_rootP
== orgsymP
)
811 symbol_rootP
= newsymP
;
812 else if (orgsymP
->x
->previous
)
814 orgsymP
->x
->previous
->x
->next
= newsymP
;
815 orgsymP
->x
->previous
= NULL
;
817 if (symbol_lastP
== orgsymP
)
818 symbol_lastP
= newsymP
;
819 else if (orgsymP
->x
->next
)
820 orgsymP
->x
->next
->x
->previous
= newsymP
;
822 /* Symbols that won't be output can't be external. */
823 S_CLEAR_EXTERNAL (orgsymP
);
824 orgsymP
->x
->previous
= orgsymP
->x
->next
= orgsymP
;
825 debug_verify_symchain (symbol_rootP
, symbol_lastP
);
827 symbol_table_insert (newsymP
);
831 /* Symbols that won't be output can't be external. */
832 S_CLEAR_EXTERNAL (newsymP
);
833 newsymP
->x
->previous
= newsymP
->x
->next
= newsymP
;
839 /* Referenced symbols, if they are forward references, need to be cloned
840 (without replacing the original) so that the value of the referenced
841 symbols at the point of use is saved by the clone. */
843 #undef symbol_clone_if_forward_ref
845 symbol_clone_if_forward_ref (symbolS
*symbolP
, int is_forward
)
848 && !symbolP
->flags
.local_symbol
849 && !symbolP
->flags
.forward_resolved
)
851 symbolS
*orig_add_symbol
= symbolP
->x
->value
.X_add_symbol
;
852 symbolS
*orig_op_symbol
= symbolP
->x
->value
.X_op_symbol
;
853 symbolS
*add_symbol
= orig_add_symbol
;
854 symbolS
*op_symbol
= orig_op_symbol
;
856 if (symbolP
->flags
.forward_ref
)
861 /* assign_symbol() clones volatile symbols; pre-existing expressions
862 hold references to the original instance, but want the current
863 value. Just repeat the lookup. */
864 if (add_symbol
&& S_IS_VOLATILE (add_symbol
))
865 add_symbol
= symbol_find_exact (S_GET_NAME (add_symbol
));
866 if (op_symbol
&& S_IS_VOLATILE (op_symbol
))
867 op_symbol
= symbol_find_exact (S_GET_NAME (op_symbol
));
870 /* Re-using resolving here, as this routine cannot get called from
871 symbol resolution code. */
872 if ((symbolP
->bsym
->section
== expr_section
873 || symbolP
->flags
.forward_ref
)
874 && !symbolP
->flags
.resolving
)
876 symbolP
->flags
.resolving
= 1;
877 add_symbol
= symbol_clone_if_forward_ref (add_symbol
, is_forward
);
878 op_symbol
= symbol_clone_if_forward_ref (op_symbol
, is_forward
);
879 symbolP
->flags
.resolving
= 0;
882 if (symbolP
->flags
.forward_ref
883 || add_symbol
!= orig_add_symbol
884 || op_symbol
!= orig_op_symbol
)
886 if (symbolP
!= &dot_symbol
)
888 symbolP
= symbol_clone (symbolP
, 0);
889 symbolP
->flags
.resolving
= 0;
893 symbolP
= symbol_temp_new_now ();
894 #ifdef tc_new_dot_label
895 tc_new_dot_label (symbolP
);
900 symbolP
->x
->value
.X_add_symbol
= add_symbol
;
901 symbolP
->x
->value
.X_op_symbol
= op_symbol
;
902 symbolP
->flags
.forward_resolved
= 1;
909 symbol_temp_new (segT seg
, fragS
*frag
, valueT ofs
)
911 return symbol_new (FAKE_LABEL_NAME
, seg
, frag
, ofs
);
915 symbol_temp_new_now (void)
917 return symbol_temp_new (now_seg
, frag_now
, frag_now_fix ());
921 symbol_temp_new_now_octets (void)
923 return symbol_temp_new (now_seg
, frag_now
, frag_now_fix_octets ());
927 symbol_temp_make (void)
929 return symbol_make (FAKE_LABEL_NAME
);
932 /* Implement symbol table lookup.
933 In: A symbol's name as a string: '\0' can't be part of a symbol name.
934 Out: NULL if the name was not in the symbol table, else the address
935 of a struct symbol associated with that name. */
938 symbol_find_exact (const char *name
)
940 return symbol_find_exact_noref (name
, 0);
944 symbol_find_exact_noref (const char *name
, int noref
)
946 symbolS
*sym
= symbol_entry_find (sy_hash
, name
);
948 /* Any references to the symbol, except for the reference in
949 .weakref, must clear this flag, such that the symbol does not
950 turn into a weak symbol. Note that we don't have to handle the
951 local_symbol case, since a weakrefd is always promoted out of the
952 local_symbol table when it is turned into a weak symbol. */
954 S_CLEAR_WEAKREFD (sym
);
960 symbol_find (const char *name
)
962 return symbol_find_noref (name
, 0);
966 symbol_find_noref (const char *name
, int noref
)
971 #ifdef tc_canonicalize_symbol_name
973 copy
= xstrdup (name
);
974 name
= tc_canonicalize_symbol_name (copy
);
978 if (! symbols_case_sensitive
)
987 name
= copy
= XNEWVEC (char, strlen (name
) + 1);
989 while ((c
= *orig
++) != '\0')
990 *copy
++ = TOUPPER (c
);
994 copy
= (char *) name
;
997 result
= symbol_find_exact_noref (name
, noref
);
1002 /* Once upon a time, symbols were kept in a singly linked list. At
1003 least coff needs to be able to rearrange them from time to time, for
1004 which a doubly linked list is much more convenient. Loic did these
1005 as macros which seemed dangerous to me so they're now functions.
1008 /* Link symbol ADDME after symbol TARGET in the chain. */
1011 symbol_append (symbolS
*addme
, symbolS
*target
,
1012 symbolS
**rootPP
, symbolS
**lastPP
)
1014 extern int symbol_table_frozen
;
1015 if (symbol_table_frozen
)
1017 if (addme
->flags
.local_symbol
)
1019 if (target
!= NULL
&& target
->flags
.local_symbol
)
1024 know (*rootPP
== NULL
);
1025 know (*lastPP
== NULL
);
1026 addme
->x
->next
= NULL
;
1027 addme
->x
->previous
= NULL
;
1031 } /* if the list is empty */
1033 if (target
->x
->next
!= NULL
)
1035 target
->x
->next
->x
->previous
= addme
;
1039 know (*lastPP
== target
);
1041 } /* if we have a next */
1043 addme
->x
->next
= target
->x
->next
;
1044 target
->x
->next
= addme
;
1045 addme
->x
->previous
= target
;
1047 debug_verify_symchain (symbol_rootP
, symbol_lastP
);
1050 /* Set the chain pointers of SYMBOL to null. */
1053 symbol_clear_list_pointers (symbolS
*symbolP
)
1055 if (symbolP
->flags
.local_symbol
)
1057 symbolP
->x
->next
= NULL
;
1058 symbolP
->x
->previous
= NULL
;
1061 /* Remove SYMBOLP from the list. */
1064 symbol_remove (symbolS
*symbolP
, symbolS
**rootPP
, symbolS
**lastPP
)
1066 if (symbolP
->flags
.local_symbol
)
1069 if (symbolP
== *rootPP
)
1071 *rootPP
= symbolP
->x
->next
;
1072 } /* if it was the root */
1074 if (symbolP
== *lastPP
)
1076 *lastPP
= symbolP
->x
->previous
;
1077 } /* if it was the tail */
1079 if (symbolP
->x
->next
!= NULL
)
1081 symbolP
->x
->next
->x
->previous
= symbolP
->x
->previous
;
1084 if (symbolP
->x
->previous
!= NULL
)
1086 symbolP
->x
->previous
->x
->next
= symbolP
->x
->next
;
1087 } /* if not first */
1089 debug_verify_symchain (*rootPP
, *lastPP
);
1092 /* Link symbol ADDME before symbol TARGET in the chain. */
1095 symbol_insert (symbolS
*addme
, symbolS
*target
,
1096 symbolS
**rootPP
, symbolS
**lastPP ATTRIBUTE_UNUSED
)
1098 extern int symbol_table_frozen
;
1099 if (symbol_table_frozen
)
1101 if (addme
->flags
.local_symbol
)
1103 if (target
->flags
.local_symbol
)
1106 if (target
->x
->previous
!= NULL
)
1108 target
->x
->previous
->x
->next
= addme
;
1112 know (*rootPP
== target
);
1114 } /* if not first */
1116 addme
->x
->previous
= target
->x
->previous
;
1117 target
->x
->previous
= addme
;
1118 addme
->x
->next
= target
;
1120 debug_verify_symchain (*rootPP
, *lastPP
);
1124 verify_symbol_chain (symbolS
*rootP
, symbolS
*lastP
)
1126 symbolS
*symbolP
= rootP
;
1128 if (symbolP
== NULL
)
1131 for (; symbol_next (symbolP
) != NULL
; symbolP
= symbol_next (symbolP
))
1133 gas_assert (symbolP
->bsym
!= NULL
);
1134 gas_assert (symbolP
->flags
.local_symbol
== 0);
1135 gas_assert (symbolP
->x
->next
->x
->previous
== symbolP
);
1138 gas_assert (lastP
== symbolP
);
1142 symbol_on_chain (symbolS
*s
, symbolS
*rootPP
, symbolS
*lastPP
)
1144 return (!s
->flags
.local_symbol
1145 && ((s
->x
->next
!= s
1146 && s
->x
->next
!= NULL
1147 && s
->x
->next
->x
->previous
== s
)
1149 && ((s
->x
->previous
!= s
1150 && s
->x
->previous
!= NULL
1151 && s
->x
->previous
->x
->next
== s
)
1155 #ifdef OBJ_COMPLEX_RELC
1158 use_complex_relocs_for (symbolS
* symp
)
1160 switch (symp
->x
->value
.X_op
)
1170 case O_bit_inclusive_or
:
1172 case O_bit_exclusive_or
:
1184 if ((S_IS_COMMON (symp
->x
->value
.X_op_symbol
)
1185 || S_IS_LOCAL (symp
->x
->value
.X_op_symbol
))
1186 && S_IS_DEFINED (symp
->x
->value
.X_op_symbol
)
1187 && S_GET_SEGMENT (symp
->x
->value
.X_op_symbol
) != expr_section
)
1194 if ((S_IS_COMMON (symp
->x
->value
.X_add_symbol
)
1195 || S_IS_LOCAL (symp
->x
->value
.X_add_symbol
))
1196 && S_IS_DEFINED (symp
->x
->value
.X_add_symbol
)
1197 && S_GET_SEGMENT (symp
->x
->value
.X_add_symbol
) != expr_section
)
1210 report_op_error (symbolS
*symp
, symbolS
*left
, operatorT op
, symbolS
*right
)
1214 segT seg_left
= left
? S_GET_SEGMENT (left
) : 0;
1215 segT seg_right
= S_GET_SEGMENT (right
);
1224 case O_uminus
: opname
= "-"; break;
1225 case O_bit_not
: opname
= "~"; break;
1226 case O_logical_not
: opname
= "!"; break;
1227 case O_multiply
: opname
= "*"; break;
1228 case O_divide
: opname
= "/"; break;
1229 case O_modulus
: opname
= "%"; break;
1230 case O_left_shift
: opname
= "<<"; break;
1231 case O_right_shift
: opname
= ">>"; break;
1232 case O_bit_inclusive_or
: opname
= "|"; break;
1233 case O_bit_or_not
: opname
= "|~"; break;
1234 case O_bit_exclusive_or
: opname
= "^"; break;
1235 case O_bit_and
: opname
= "&"; break;
1236 case O_add
: opname
= "+"; break;
1237 case O_subtract
: opname
= "-"; break;
1238 case O_eq
: opname
= "=="; break;
1239 case O_ne
: opname
= "!="; break;
1240 case O_lt
: opname
= "<"; break;
1241 case O_le
: opname
= "<="; break;
1242 case O_ge
: opname
= ">="; break;
1243 case O_gt
: opname
= ">"; break;
1244 case O_logical_and
: opname
= "&&"; break;
1245 case O_logical_or
: opname
= "||"; break;
1248 if (expr_symbol_where (symp
, &file
, &line
))
1251 as_bad_where (file
, line
,
1252 _("invalid operands (%s and %s sections) for `%s'"),
1253 seg_left
->name
, seg_right
->name
, opname
);
1255 as_bad_where (file
, line
,
1256 _("invalid operand (%s section) for `%s'"),
1257 seg_right
->name
, opname
);
1261 const char *sname
= S_GET_NAME (symp
);
1264 as_bad (_("invalid operands (%s and %s sections) for `%s' when setting `%s'"),
1265 seg_left
->name
, seg_right
->name
, opname
, sname
);
1267 as_bad (_("invalid operand (%s section) for `%s' when setting `%s'"),
1268 seg_right
->name
, opname
, sname
);
1272 /* Resolve the value of a symbol. This is called during the final
1273 pass over the symbol table to resolve any symbols with complex
1277 resolve_symbol_value (symbolS
*symp
)
1283 if (symp
->flags
.local_symbol
)
1285 struct local_symbol
*locsym
= (struct local_symbol
*) symp
;
1287 final_val
= locsym
->value
;
1288 if (locsym
->flags
.resolved
)
1291 /* Symbols whose section has SEC_ELF_OCTETS set,
1292 resolve to octets instead of target bytes. */
1293 if (locsym
->section
->flags
& SEC_OCTETS
)
1294 final_val
+= locsym
->frag
->fr_address
;
1296 final_val
+= locsym
->frag
->fr_address
/ OCTETS_PER_BYTE
;
1300 locsym
->value
= final_val
;
1301 locsym
->flags
.resolved
= 1;
1307 if (symp
->flags
.resolved
)
1310 while (symp
->x
->value
.X_op
== O_symbol
)
1312 final_val
+= symp
->x
->value
.X_add_number
;
1313 symp
= symp
->x
->value
.X_add_symbol
;
1314 if (symp
->flags
.local_symbol
)
1316 struct local_symbol
*locsym
= (struct local_symbol
*) symp
;
1317 final_val
+= locsym
->value
;
1320 if (!symp
->flags
.resolved
)
1323 if (symp
->x
->value
.X_op
== O_constant
)
1324 final_val
+= symp
->x
->value
.X_add_number
;
1331 final_seg
= S_GET_SEGMENT (symp
);
1333 if (symp
->flags
.resolving
)
1336 as_bad (_("symbol definition loop encountered at `%s'"),
1341 #ifdef OBJ_COMPLEX_RELC
1342 else if (final_seg
== expr_section
1343 && use_complex_relocs_for (symp
))
1345 symbolS
* relc_symbol
= NULL
;
1346 char * relc_symbol_name
= NULL
;
1348 relc_symbol_name
= symbol_relc_make_expr (& symp
->x
->value
);
1350 /* For debugging, print out conversion input & output. */
1352 print_expr (& symp
->x
->value
);
1353 if (relc_symbol_name
)
1354 fprintf (stderr
, "-> relc symbol: %s\n", relc_symbol_name
);
1357 if (relc_symbol_name
!= NULL
)
1358 relc_symbol
= symbol_new (relc_symbol_name
, undefined_section
,
1359 &zero_address_frag
, 0);
1361 if (relc_symbol
== NULL
)
1363 as_bad (_("cannot convert expression symbol %s to complex relocation"),
1369 symbol_table_insert (relc_symbol
);
1371 /* S_CLEAR_EXTERNAL (relc_symbol); */
1372 if (symp
->bsym
->flags
& BSF_SRELC
)
1373 relc_symbol
->bsym
->flags
|= BSF_SRELC
;
1375 relc_symbol
->bsym
->flags
|= BSF_RELC
;
1376 /* symp->bsym->flags |= BSF_RELC; */
1377 copy_symbol_attributes (symp
, relc_symbol
);
1378 symp
->x
->value
.X_op
= O_symbol
;
1379 symp
->x
->value
.X_add_symbol
= relc_symbol
;
1380 symp
->x
->value
.X_add_number
= 0;
1385 final_seg
= undefined_section
;
1386 goto exit_dont_set_value
;
1391 symbolS
*add_symbol
, *op_symbol
;
1392 offsetT left
, right
;
1393 segT seg_left
, seg_right
;
1397 symp
->flags
.resolving
= 1;
1399 /* Help out with CSE. */
1400 add_symbol
= symp
->x
->value
.X_add_symbol
;
1401 op_symbol
= symp
->x
->value
.X_op_symbol
;
1402 final_val
= symp
->x
->value
.X_add_number
;
1403 op
= symp
->x
->value
.X_op
;
1416 /* Symbols whose section has SEC_ELF_OCTETS set,
1417 resolve to octets instead of target bytes. */
1418 if (symp
->bsym
->section
->flags
& SEC_OCTETS
)
1419 final_val
+= symp
->frag
->fr_address
;
1421 final_val
+= symp
->frag
->fr_address
/ OCTETS_PER_BYTE
;
1422 if (final_seg
== expr_section
)
1423 final_seg
= absolute_section
;
1433 left
= resolve_symbol_value (add_symbol
);
1434 seg_left
= S_GET_SEGMENT (add_symbol
);
1436 symp
->x
->value
.X_op_symbol
= NULL
;
1439 if (S_IS_WEAKREFR (symp
))
1441 gas_assert (final_val
== 0);
1442 if (S_IS_WEAKREFR (add_symbol
))
1444 gas_assert (add_symbol
->x
->value
.X_op
== O_symbol
1445 && add_symbol
->x
->value
.X_add_number
== 0);
1446 add_symbol
= add_symbol
->x
->value
.X_add_symbol
;
1447 gas_assert (! S_IS_WEAKREFR (add_symbol
));
1448 symp
->x
->value
.X_add_symbol
= add_symbol
;
1452 if (symp
->flags
.mri_common
)
1454 /* This is a symbol inside an MRI common section. The
1455 relocation routines are going to handle it specially.
1456 Don't change the value. */
1457 resolved
= symbol_resolved_p (add_symbol
);
1461 /* Don't leave symbol loops. */
1463 && !add_symbol
->flags
.local_symbol
1464 && add_symbol
->flags
.resolving
)
1467 if (finalize_syms
&& final_val
== 0
1469 /* Avoid changing symp's "within" when dealing with
1470 AIX debug symbols. For some storage classes, "within"
1471 have a special meaning.
1472 C_DWARF should behave like on Linux, thus this check
1473 isn't done to be closer. */
1474 && ((symbol_get_bfdsym (symp
)->flags
& BSF_DEBUGGING
) == 0
1475 || (S_GET_STORAGE_CLASS (symp
) == C_DWARF
))
1479 if (add_symbol
->flags
.local_symbol
)
1480 add_symbol
= local_symbol_convert (add_symbol
);
1481 copy_symbol_attributes (symp
, add_symbol
);
1484 /* If we have equated this symbol to an undefined or common
1485 symbol, keep X_op set to O_symbol, and don't change
1486 X_add_number. This permits the routine which writes out
1487 relocation to detect this case, and convert the
1488 relocation to be against the symbol to which this symbol
1490 if (seg_left
== undefined_section
1491 || bfd_is_com_section (seg_left
)
1492 #if defined (OBJ_COFF) && defined (TE_PE)
1493 || S_IS_WEAK (add_symbol
)
1496 && ((final_seg
== expr_section
1497 && seg_left
!= expr_section
1498 && seg_left
!= absolute_section
)
1499 || symbol_shadow_p (symp
))))
1503 symp
->x
->value
.X_op
= O_symbol
;
1504 symp
->x
->value
.X_add_symbol
= add_symbol
;
1505 symp
->x
->value
.X_add_number
= final_val
;
1506 /* Use X_op_symbol as a flag. */
1507 symp
->x
->value
.X_op_symbol
= add_symbol
;
1509 final_seg
= seg_left
;
1510 final_val
+= symp
->frag
->fr_address
+ left
;
1511 resolved
= symbol_resolved_p (add_symbol
);
1512 symp
->flags
.resolving
= 0;
1514 if (op
== O_secidx
&& seg_left
!= undefined_section
)
1520 goto exit_dont_set_value
;
1524 final_val
+= symp
->frag
->fr_address
+ left
;
1525 if (final_seg
== expr_section
|| final_seg
== undefined_section
)
1526 final_seg
= seg_left
;
1529 resolved
= symbol_resolved_p (add_symbol
);
1530 if (S_IS_WEAKREFR (symp
))
1532 symp
->flags
.resolving
= 0;
1533 goto exit_dont_set_value
;
1540 left
= resolve_symbol_value (add_symbol
);
1541 seg_left
= S_GET_SEGMENT (add_symbol
);
1543 /* By reducing these to the relevant dyadic operator, we get
1544 !S -> S == 0 permitted on anything,
1545 -S -> 0 - S only permitted on absolute
1546 ~S -> S ^ ~0 only permitted on absolute */
1547 if (op
!= O_logical_not
&& seg_left
!= absolute_section
1549 report_op_error (symp
, NULL
, op
, add_symbol
);
1551 if (final_seg
== expr_section
|| final_seg
== undefined_section
)
1552 final_seg
= absolute_section
;
1556 else if (op
== O_logical_not
)
1561 final_val
+= left
+ symp
->frag
->fr_address
;
1563 resolved
= symbol_resolved_p (add_symbol
);
1571 case O_bit_inclusive_or
:
1573 case O_bit_exclusive_or
:
1585 left
= resolve_symbol_value (add_symbol
);
1586 right
= resolve_symbol_value (op_symbol
);
1587 seg_left
= S_GET_SEGMENT (add_symbol
);
1588 seg_right
= S_GET_SEGMENT (op_symbol
);
1590 /* Simplify addition or subtraction of a constant by folding the
1591 constant into X_add_number. */
1594 if (seg_right
== absolute_section
)
1599 else if (seg_left
== absolute_section
)
1602 add_symbol
= op_symbol
;
1604 seg_left
= seg_right
;
1608 else if (op
== O_subtract
)
1610 if (seg_right
== absolute_section
)
1618 /* Equality and non-equality tests are permitted on anything.
1619 Subtraction, and other comparison operators are permitted if
1620 both operands are in the same section. Otherwise, both
1621 operands must be absolute. We already handled the case of
1622 addition or subtraction of a constant above. This will
1623 probably need to be changed for an object file format which
1624 supports arbitrary expressions. */
1625 if (!(seg_left
== absolute_section
1626 && seg_right
== absolute_section
)
1627 && !(op
== O_eq
|| op
== O_ne
)
1628 && !((op
== O_subtract
1629 || op
== O_lt
|| op
== O_le
|| op
== O_ge
|| op
== O_gt
)
1630 && seg_left
== seg_right
1631 && (seg_left
!= undefined_section
1632 || add_symbol
== op_symbol
)))
1634 /* Don't emit messages unless we're finalizing the symbol value,
1635 otherwise we may get the same message multiple times. */
1637 report_op_error (symp
, add_symbol
, op
, op_symbol
);
1638 /* However do not move the symbol into the absolute section
1639 if it cannot currently be resolved - this would confuse
1640 other parts of the assembler into believing that the
1641 expression had been evaluated to zero. */
1647 && (final_seg
== expr_section
|| final_seg
== undefined_section
))
1648 final_seg
= absolute_section
;
1650 /* Check for division by zero. */
1651 if ((op
== O_divide
|| op
== O_modulus
) && right
== 0)
1653 /* If seg_right is not absolute_section, then we've
1654 already issued a warning about using a bad symbol. */
1655 if (seg_right
== absolute_section
&& finalize_syms
)
1660 if (expr_symbol_where (symp
, &file
, &line
))
1661 as_bad_where (file
, line
, _("division by zero"));
1663 as_bad (_("division by zero when setting `%s'"),
1669 if ((op
== O_left_shift
|| op
== O_right_shift
)
1670 && (valueT
) right
>= sizeof (valueT
) * CHAR_BIT
)
1672 as_warn_value_out_of_range (_("shift count"), right
, 0,
1673 sizeof (valueT
) * CHAR_BIT
- 1,
1678 switch (symp
->x
->value
.X_op
)
1680 case O_multiply
: left
*= right
; break;
1681 case O_divide
: left
/= right
; break;
1682 case O_modulus
: left
%= right
; break;
1684 left
= (valueT
) left
<< (valueT
) right
; break;
1686 left
= (valueT
) left
>> (valueT
) right
; break;
1687 case O_bit_inclusive_or
: left
|= right
; break;
1688 case O_bit_or_not
: left
|= ~right
; break;
1689 case O_bit_exclusive_or
: left
^= right
; break;
1690 case O_bit_and
: left
&= right
; break;
1691 case O_add
: left
+= right
; break;
1692 case O_subtract
: left
-= right
; break;
1695 left
= (left
== right
&& seg_left
== seg_right
1696 && (seg_left
!= undefined_section
1697 || add_symbol
== op_symbol
)
1698 ? ~ (offsetT
) 0 : 0);
1699 if (symp
->x
->value
.X_op
== O_ne
)
1702 case O_lt
: left
= left
< right
? ~ (offsetT
) 0 : 0; break;
1703 case O_le
: left
= left
<= right
? ~ (offsetT
) 0 : 0; break;
1704 case O_ge
: left
= left
>= right
? ~ (offsetT
) 0 : 0; break;
1705 case O_gt
: left
= left
> right
? ~ (offsetT
) 0 : 0; break;
1706 case O_logical_and
: left
= left
&& right
; break;
1707 case O_logical_or
: left
= left
|| right
; break;
1712 /* See PR 20895 for a reproducer. */
1713 as_bad (_("Invalid operation on symbol"));
1714 goto exit_dont_set_value
;
1720 final_val
+= symp
->frag
->fr_address
+ left
;
1721 if (final_seg
== expr_section
|| final_seg
== undefined_section
)
1723 if (seg_left
== undefined_section
1724 || seg_right
== undefined_section
)
1725 final_seg
= undefined_section
;
1726 else if (seg_left
== absolute_section
)
1727 final_seg
= seg_right
;
1729 final_seg
= seg_left
;
1731 resolved
= (symbol_resolved_p (add_symbol
)
1732 && symbol_resolved_p (op_symbol
));
1737 /* Give an error (below) if not in expr_section. We don't
1738 want to worry about expr_section symbols, because they
1739 are fictional (they are created as part of expression
1740 resolution), and any problems may not actually mean
1745 symp
->flags
.resolving
= 0;
1749 S_SET_VALUE (symp
, final_val
);
1751 exit_dont_set_value
:
1752 /* Always set the segment, even if not finalizing the value.
1753 The segment is used to determine whether a symbol is defined. */
1754 S_SET_SEGMENT (symp
, final_seg
);
1756 /* Don't worry if we can't resolve an expr_section symbol. */
1760 symp
->flags
.resolved
= 1;
1761 else if (S_GET_SEGMENT (symp
) != expr_section
)
1763 as_bad (_("can't resolve value for symbol `%s'"),
1765 symp
->flags
.resolved
= 1;
1772 /* A static function passed to hash_traverse. */
1775 resolve_local_symbol (void **slot
, void *arg ATTRIBUTE_UNUSED
)
1777 symbol_entry_t
*entry
= *((symbol_entry_t
**) slot
);
1778 if (entry
->sy
.flags
.local_symbol
)
1779 resolve_symbol_value (&entry
->sy
);
1784 /* Resolve all local symbols. */
1787 resolve_local_symbol_values (void)
1789 htab_traverse_noresize (sy_hash
, resolve_local_symbol
, NULL
);
1792 /* Obtain the current value of a symbol without changing any
1793 sub-expressions used. */
1796 snapshot_symbol (symbolS
**symbolPP
, valueT
*valueP
, segT
*segP
, fragS
**fragPP
)
1798 symbolS
*symbolP
= *symbolPP
;
1800 if (symbolP
->flags
.local_symbol
)
1802 struct local_symbol
*locsym
= (struct local_symbol
*) symbolP
;
1804 *valueP
= locsym
->value
;
1805 *segP
= locsym
->section
;
1806 *fragPP
= locsym
->frag
;
1810 expressionS exp
= symbolP
->x
->value
;
1812 if (!symbolP
->flags
.resolved
&& exp
.X_op
!= O_illegal
)
1816 if (symbolP
->flags
.resolving
)
1818 symbolP
->flags
.resolving
= 1;
1819 resolved
= resolve_expression (&exp
);
1820 symbolP
->flags
.resolving
= 0;
1828 if (!symbol_equated_p (symbolP
))
1833 symbolP
= exp
.X_add_symbol
;
1840 *symbolPP
= symbolP
;
1842 /* A bogus input file can result in resolve_expression()
1843 generating a local symbol, so we have to check again. */
1844 if (symbolP
->flags
.local_symbol
)
1846 struct local_symbol
*locsym
= (struct local_symbol
*) symbolP
;
1848 *valueP
= locsym
->value
;
1849 *segP
= locsym
->section
;
1850 *fragPP
= locsym
->frag
;
1854 *valueP
= exp
.X_add_number
;
1855 *segP
= symbolP
->bsym
->section
;
1856 *fragPP
= symbolP
->frag
;
1859 if (*segP
== expr_section
)
1862 case O_constant
: *segP
= absolute_section
; break;
1863 case O_register
: *segP
= reg_section
; break;
1871 /* Dollar labels look like a number followed by a dollar sign. Eg, "42$".
1872 They are *really* local. That is, they go out of scope whenever we see a
1873 label that isn't local. Also, like fb labels, there can be multiple
1874 instances of a dollar label. Therefor, we name encode each instance with
1875 the instance number, keep a list of defined symbols separate from the real
1876 symbol table, and we treat these buggers as a sparse array. */
1878 typedef unsigned int dollar_ent
;
1879 static dollar_ent
*dollar_labels
;
1880 static dollar_ent
*dollar_label_instances
;
1881 static char *dollar_label_defines
;
1882 static size_t dollar_label_count
;
1883 static size_t dollar_label_max
;
1886 dollar_label_defined (unsigned int label
)
1890 know ((dollar_labels
!= NULL
) || (dollar_label_count
== 0));
1892 for (i
= dollar_labels
; i
< dollar_labels
+ dollar_label_count
; ++i
)
1894 return dollar_label_defines
[i
- dollar_labels
];
1896 /* If we get here, label isn't defined. */
1901 dollar_label_instance (unsigned int label
)
1905 know ((dollar_labels
!= NULL
) || (dollar_label_count
== 0));
1907 for (i
= dollar_labels
; i
< dollar_labels
+ dollar_label_count
; ++i
)
1909 return (dollar_label_instances
[i
- dollar_labels
]);
1911 /* If we get here, we haven't seen the label before.
1912 Therefore its instance count is zero. */
1917 dollar_label_clear (void)
1919 if (dollar_label_count
)
1920 memset (dollar_label_defines
, '\0', dollar_label_count
);
1923 #define DOLLAR_LABEL_BUMP_BY 10
1926 define_dollar_label (unsigned int label
)
1930 for (i
= dollar_labels
; i
< dollar_labels
+ dollar_label_count
; ++i
)
1933 ++dollar_label_instances
[i
- dollar_labels
];
1934 dollar_label_defines
[i
- dollar_labels
] = 1;
1938 /* If we get to here, we don't have label listed yet. */
1940 if (dollar_labels
== NULL
)
1942 dollar_labels
= XNEWVEC (dollar_ent
, DOLLAR_LABEL_BUMP_BY
);
1943 dollar_label_instances
= XNEWVEC (dollar_ent
, DOLLAR_LABEL_BUMP_BY
);
1944 dollar_label_defines
= XNEWVEC (char, DOLLAR_LABEL_BUMP_BY
);
1945 dollar_label_max
= DOLLAR_LABEL_BUMP_BY
;
1946 dollar_label_count
= 0;
1948 else if (dollar_label_count
== dollar_label_max
)
1950 dollar_label_max
+= DOLLAR_LABEL_BUMP_BY
;
1951 dollar_labels
= XRESIZEVEC (dollar_ent
, dollar_labels
,
1953 dollar_label_instances
= XRESIZEVEC (dollar_ent
,
1954 dollar_label_instances
,
1956 dollar_label_defines
= XRESIZEVEC (char, dollar_label_defines
,
1958 } /* if we needed to grow */
1960 dollar_labels
[dollar_label_count
] = label
;
1961 dollar_label_instances
[dollar_label_count
] = 1;
1962 dollar_label_defines
[dollar_label_count
] = 1;
1963 ++dollar_label_count
;
1966 /* Caller must copy returned name: we re-use the area for the next name.
1968 The mth occurrence of label n: is turned into the symbol "Ln^Am"
1969 where n is the label number and m is the instance number. "L" makes
1970 it a label discarded unless debugging and "^A"('\1') ensures no
1971 ordinary symbol SHOULD get the same name as a local label
1972 symbol. The first "4:" is "L4^A1" - the m numbers begin at 1.
1974 fb labels get the same treatment, except that ^B is used in place
1977 AUGEND is 0 for current instance, 1 for new instance. */
1980 dollar_label_name (unsigned int n
, unsigned int augend
)
1982 /* Returned to caller, then copied. Used for created names ("4f"). */
1983 static char symbol_name_build
[24];
1984 char *p
= symbol_name_build
;
1986 #ifdef LOCAL_LABEL_PREFIX
1987 *p
++ = LOCAL_LABEL_PREFIX
;
1989 sprintf (p
, "L%u%c%u",
1990 n
, DOLLAR_LABEL_CHAR
, dollar_label_instance (n
) + augend
);
1991 return symbol_name_build
;
1994 /* Somebody else's idea of local labels. They are made by "n:" where n
1995 is any decimal digit. Refer to them with
1996 "nb" for previous (backward) n:
1997 or "nf" for next (forward) n:.
1999 We do a little better and let n be any number, not just a single digit, but
2000 since the other guy's assembler only does ten, we treat the first ten
2003 Like someone else's assembler, we have one set of local label counters for
2004 entire assembly, not one set per (sub)segment like in most assemblers. This
2005 implies that one can refer to a label in another segment, and indeed some
2006 crufty compilers have done just that.
2008 Since there could be a LOT of these things, treat them as a sparse
2011 #define FB_LABEL_SPECIAL (10)
2013 typedef unsigned int fb_ent
;
2014 static fb_ent fb_low_counter
[FB_LABEL_SPECIAL
];
2015 static fb_ent
*fb_labels
;
2016 static fb_ent
*fb_label_instances
;
2017 static size_t fb_label_count
;
2018 static size_t fb_label_max
;
2020 /* This must be more than FB_LABEL_SPECIAL. */
2021 #define FB_LABEL_BUMP_BY (FB_LABEL_SPECIAL + 6)
2024 fb_label_init (void)
2026 memset ((void *) fb_low_counter
, '\0', sizeof (fb_low_counter
));
2029 /* Add one to the instance number of this fb label. */
2032 fb_label_instance_inc (unsigned int label
)
2036 if (label
< FB_LABEL_SPECIAL
)
2038 ++fb_low_counter
[label
];
2042 if (fb_labels
!= NULL
)
2044 for (i
= fb_labels
+ FB_LABEL_SPECIAL
;
2045 i
< fb_labels
+ fb_label_count
; ++i
)
2049 ++fb_label_instances
[i
- fb_labels
];
2051 } /* if we find it */
2052 } /* for each existing label */
2055 /* If we get to here, we don't have label listed yet. */
2057 if (fb_labels
== NULL
)
2059 fb_labels
= XNEWVEC (fb_ent
, FB_LABEL_BUMP_BY
);
2060 fb_label_instances
= XNEWVEC (fb_ent
, FB_LABEL_BUMP_BY
);
2061 fb_label_max
= FB_LABEL_BUMP_BY
;
2062 fb_label_count
= FB_LABEL_SPECIAL
;
2065 else if (fb_label_count
== fb_label_max
)
2067 fb_label_max
+= FB_LABEL_BUMP_BY
;
2068 fb_labels
= XRESIZEVEC (fb_ent
, fb_labels
, fb_label_max
);
2069 fb_label_instances
= XRESIZEVEC (fb_ent
, fb_label_instances
,
2071 } /* if we needed to grow */
2073 fb_labels
[fb_label_count
] = label
;
2074 fb_label_instances
[fb_label_count
] = 1;
2079 fb_label_instance (unsigned int label
)
2083 if (label
< FB_LABEL_SPECIAL
)
2084 return (fb_low_counter
[label
]);
2086 if (fb_labels
!= NULL
)
2088 for (i
= fb_labels
+ FB_LABEL_SPECIAL
;
2089 i
< fb_labels
+ fb_label_count
; ++i
)
2092 return (fb_label_instances
[i
- fb_labels
]);
2096 /* We didn't find the label, so this must be a reference to the
2101 /* Caller must copy returned name: we re-use the area for the next name.
2103 The mth occurrence of label n: is turned into the symbol "Ln^Bm"
2104 where n is the label number and m is the instance number. "L" makes
2105 it a label discarded unless debugging and "^B"('\2') ensures no
2106 ordinary symbol SHOULD get the same name as a local label
2107 symbol. The first "4:" is "L4^B1" - the m numbers begin at 1.
2109 dollar labels get the same treatment, except that ^A is used in
2112 AUGEND is 0 for nb, 1 for n:, nf. */
2115 fb_label_name (unsigned int n
, unsigned int augend
)
2117 /* Returned to caller, then copied. Used for created names ("4f"). */
2118 static char symbol_name_build
[24];
2119 char *p
= symbol_name_build
;
2122 know (augend
<= 2 /* See mmix_fb_label. */);
2127 #ifdef LOCAL_LABEL_PREFIX
2128 *p
++ = LOCAL_LABEL_PREFIX
;
2130 sprintf (p
, "L%u%c%u",
2131 n
, LOCAL_LABEL_CHAR
, fb_label_instance (n
) + augend
);
2132 return symbol_name_build
;
2135 /* Decode name that may have been generated by foo_label_name() above.
2136 If the name wasn't generated by foo_label_name(), then return it
2137 unaltered. This is used for error messages. */
2140 decode_local_label_name (char *s
)
2143 char *symbol_decode
;
2145 int instance_number
;
2147 const char *message_format
;
2150 #ifdef LOCAL_LABEL_PREFIX
2151 if (s
[lindex
] == LOCAL_LABEL_PREFIX
)
2155 if (s
[lindex
] != 'L')
2158 for (label_number
= 0, p
= s
+ lindex
+ 1; ISDIGIT (*p
); ++p
)
2159 label_number
= (10 * label_number
) + *p
- '0';
2161 if (*p
== DOLLAR_LABEL_CHAR
)
2163 else if (*p
== LOCAL_LABEL_CHAR
)
2168 for (instance_number
= 0, p
++; ISDIGIT (*p
); ++p
)
2169 instance_number
= (10 * instance_number
) + *p
- '0';
2171 message_format
= _("\"%d\" (instance number %d of a %s label)");
2172 symbol_decode
= notes_alloc (strlen (message_format
) + 30);
2173 sprintf (symbol_decode
, message_format
, label_number
, instance_number
, type
);
2175 return symbol_decode
;
2178 /* Get the value of a symbol. */
2181 S_GET_VALUE (symbolS
*s
)
2183 if (s
->flags
.local_symbol
)
2184 return resolve_symbol_value (s
);
2186 if (!s
->flags
.resolved
)
2188 valueT val
= resolve_symbol_value (s
);
2192 if (S_IS_WEAKREFR (s
))
2193 return S_GET_VALUE (s
->x
->value
.X_add_symbol
);
2195 if (s
->x
->value
.X_op
!= O_constant
)
2197 if (! s
->flags
.resolved
2198 || s
->x
->value
.X_op
!= O_symbol
2199 || (S_IS_DEFINED (s
) && ! S_IS_COMMON (s
)))
2200 as_bad (_("attempt to get value of unresolved symbol `%s'"),
2203 return (valueT
) s
->x
->value
.X_add_number
;
2206 /* Set the value of a symbol. */
2209 S_SET_VALUE (symbolS
*s
, valueT val
)
2211 if (s
->flags
.local_symbol
)
2213 ((struct local_symbol
*) s
)->value
= val
;
2217 s
->x
->value
.X_op
= O_constant
;
2218 s
->x
->value
.X_add_number
= (offsetT
) val
;
2219 s
->x
->value
.X_unsigned
= 0;
2220 S_CLEAR_WEAKREFR (s
);
2224 copy_symbol_attributes (symbolS
*dest
, symbolS
*src
)
2226 if (dest
->flags
.local_symbol
)
2227 dest
= local_symbol_convert (dest
);
2228 if (src
->flags
.local_symbol
)
2229 src
= local_symbol_convert (src
);
2231 /* In an expression, transfer the settings of these flags.
2232 The user can override later, of course. */
2233 #define COPIED_SYMFLAGS (BSF_FUNCTION | BSF_OBJECT \
2234 | BSF_GNU_INDIRECT_FUNCTION)
2235 dest
->bsym
->flags
|= src
->bsym
->flags
& COPIED_SYMFLAGS
;
2237 #ifdef OBJ_COPY_SYMBOL_ATTRIBUTES
2238 OBJ_COPY_SYMBOL_ATTRIBUTES (dest
, src
);
2241 #ifdef TC_COPY_SYMBOL_ATTRIBUTES
2242 TC_COPY_SYMBOL_ATTRIBUTES (dest
, src
);
2247 S_IS_FUNCTION (symbolS
*s
)
2251 if (s
->flags
.local_symbol
)
2254 flags
= s
->bsym
->flags
;
2256 return (flags
& BSF_FUNCTION
) != 0;
2260 S_IS_EXTERNAL (symbolS
*s
)
2264 if (s
->flags
.local_symbol
)
2267 flags
= s
->bsym
->flags
;
2270 if ((flags
& BSF_LOCAL
) && (flags
& BSF_GLOBAL
))
2273 return (flags
& BSF_GLOBAL
) != 0;
2277 S_IS_WEAK (symbolS
*s
)
2279 if (s
->flags
.local_symbol
)
2281 /* Conceptually, a weakrefr is weak if the referenced symbol is. We
2282 could probably handle a WEAKREFR as always weak though. E.g., if
2283 the referenced symbol has lost its weak status, there's no reason
2284 to keep handling the weakrefr as if it was weak. */
2285 if (S_IS_WEAKREFR (s
))
2286 return S_IS_WEAK (s
->x
->value
.X_add_symbol
);
2287 return (s
->bsym
->flags
& BSF_WEAK
) != 0;
2291 S_IS_WEAKREFR (symbolS
*s
)
2293 if (s
->flags
.local_symbol
)
2295 return s
->flags
.weakrefr
!= 0;
2299 S_IS_WEAKREFD (symbolS
*s
)
2301 if (s
->flags
.local_symbol
)
2303 return s
->flags
.weakrefd
!= 0;
2307 S_IS_COMMON (symbolS
*s
)
2309 if (s
->flags
.local_symbol
)
2311 return bfd_is_com_section (s
->bsym
->section
);
2315 S_IS_DEFINED (symbolS
*s
)
2317 if (s
->flags
.local_symbol
)
2318 return ((struct local_symbol
*) s
)->section
!= undefined_section
;
2319 return s
->bsym
->section
!= undefined_section
;
2323 #ifndef EXTERN_FORCE_RELOC
2324 #define EXTERN_FORCE_RELOC IS_ELF
2327 /* Return true for symbols that should not be reduced to section
2328 symbols or eliminated from expressions, because they may be
2329 overridden by the linker. */
2331 S_FORCE_RELOC (symbolS
*s
, int strict
)
2334 if (s
->flags
.local_symbol
)
2335 sec
= ((struct local_symbol
*) s
)->section
;
2339 && ((s
->bsym
->flags
& BSF_WEAK
) != 0
2340 || (EXTERN_FORCE_RELOC
2341 && (s
->bsym
->flags
& BSF_GLOBAL
) != 0)))
2342 || (s
->bsym
->flags
& BSF_GNU_INDIRECT_FUNCTION
) != 0)
2344 sec
= s
->bsym
->section
;
2346 return bfd_is_und_section (sec
) || bfd_is_com_section (sec
);
2350 S_IS_DEBUG (symbolS
*s
)
2352 if (s
->flags
.local_symbol
)
2354 if (s
->bsym
->flags
& BSF_DEBUGGING
)
2360 S_IS_LOCAL (symbolS
*s
)
2365 if (s
->flags
.local_symbol
)
2368 flags
= s
->bsym
->flags
;
2371 if ((flags
& BSF_LOCAL
) && (flags
& BSF_GLOBAL
))
2374 if (bfd_asymbol_section (s
->bsym
) == reg_section
)
2377 if (flag_strip_local_absolute
2378 /* Keep BSF_FILE symbols in order to allow debuggers to identify
2379 the source file even when the object file is stripped. */
2380 && (flags
& (BSF_GLOBAL
| BSF_FILE
)) == 0
2381 && bfd_asymbol_section (s
->bsym
) == absolute_section
)
2384 name
= S_GET_NAME (s
);
2385 return (name
!= NULL
2387 && (strchr (name
, DOLLAR_LABEL_CHAR
)
2388 || strchr (name
, LOCAL_LABEL_CHAR
)
2389 #if FAKE_LABEL_CHAR != DOLLAR_LABEL_CHAR
2390 || strchr (name
, FAKE_LABEL_CHAR
)
2392 || TC_LABEL_IS_LOCAL (name
)
2393 || (! flag_keep_locals
2394 && (bfd_is_local_label (stdoutput
, s
->bsym
)
2397 && name
[1] == '?')))));
2401 S_IS_STABD (symbolS
*s
)
2403 return S_GET_NAME (s
) == 0;
2407 S_CAN_BE_REDEFINED (const symbolS
*s
)
2409 if (s
->flags
.local_symbol
)
2410 return (((struct local_symbol
*) s
)->frag
2411 == &predefined_address_frag
);
2412 /* Permit register names to be redefined. */
2413 return s
->bsym
->section
== reg_section
;
2417 S_IS_VOLATILE (const symbolS
*s
)
2419 if (s
->flags
.local_symbol
)
2421 return s
->flags
.volatil
;
2425 S_IS_FORWARD_REF (const symbolS
*s
)
2427 if (s
->flags
.local_symbol
)
2429 return s
->flags
.forward_ref
;
2433 S_GET_NAME (symbolS
*s
)
2439 S_GET_SEGMENT (symbolS
*s
)
2441 if (s
->flags
.local_symbol
)
2442 return ((struct local_symbol
*) s
)->section
;
2443 return s
->bsym
->section
;
2447 S_SET_SEGMENT (symbolS
*s
, segT seg
)
2449 if (s
->flags
.local_symbol
)
2451 ((struct local_symbol
*) s
)->section
= seg
;
2455 /* Don't reassign section symbols. The direct reason is to prevent seg
2456 faults assigning back to const global symbols such as *ABS*, but it
2457 shouldn't happen anyway. */
2458 if (s
->bsym
->flags
& BSF_SECTION_SYM
)
2460 if (s
->bsym
->section
!= seg
)
2465 if (multibyte_handling
== multibyte_warn_syms
2466 && ! s
->flags
.local_symbol
2467 && seg
!= undefined_section
2468 && ! s
->flags
.multibyte_warned
2469 && scan_for_multibyte_characters ((const unsigned char *) s
->name
,
2470 (const unsigned char *) s
->name
+ strlen (s
->name
),
2473 as_warn (_("symbol '%s' contains multibyte characters"), s
->name
);
2474 s
->flags
.multibyte_warned
= 1;
2477 s
->bsym
->section
= seg
;
2482 S_SET_EXTERNAL (symbolS
*s
)
2484 if (s
->flags
.local_symbol
)
2485 s
= local_symbol_convert (s
);
2486 if ((s
->bsym
->flags
& BSF_WEAK
) != 0)
2488 /* Let .weak override .global. */
2491 if (s
->bsym
->flags
& BSF_SECTION_SYM
)
2493 /* Do not reassign section symbols. */
2494 as_warn (_("can't make section symbol global"));
2497 #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
2498 if (S_GET_SEGMENT (s
) == reg_section
)
2500 as_bad (_("can't make register symbol global"));
2504 s
->bsym
->flags
|= BSF_GLOBAL
;
2505 s
->bsym
->flags
&= ~(BSF_LOCAL
| BSF_WEAK
);
2508 if (! an_external_name
&& S_GET_NAME(s
)[0] != '.')
2509 an_external_name
= S_GET_NAME (s
);
2514 S_CLEAR_EXTERNAL (symbolS
*s
)
2516 if (s
->flags
.local_symbol
)
2518 if ((s
->bsym
->flags
& BSF_WEAK
) != 0)
2520 /* Let .weak override. */
2523 s
->bsym
->flags
|= BSF_LOCAL
;
2524 s
->bsym
->flags
&= ~(BSF_GLOBAL
| BSF_WEAK
);
2528 S_SET_WEAK (symbolS
*s
)
2530 if (s
->flags
.local_symbol
)
2531 s
= local_symbol_convert (s
);
2532 #ifdef obj_set_weak_hook
2533 obj_set_weak_hook (s
);
2535 s
->bsym
->flags
|= BSF_WEAK
;
2536 s
->bsym
->flags
&= ~(BSF_GLOBAL
| BSF_LOCAL
);
2540 S_SET_WEAKREFR (symbolS
*s
)
2542 if (s
->flags
.local_symbol
)
2543 s
= local_symbol_convert (s
);
2544 s
->flags
.weakrefr
= 1;
2545 /* If the alias was already used, make sure we mark the target as
2546 used as well, otherwise it might be dropped from the symbol
2547 table. This may have unintended side effects if the alias is
2548 later redirected to another symbol, such as keeping the unused
2549 previous target in the symbol table. Since it will be weak, it's
2552 symbol_mark_used (s
->x
->value
.X_add_symbol
);
2556 S_CLEAR_WEAKREFR (symbolS
*s
)
2558 if (s
->flags
.local_symbol
)
2560 s
->flags
.weakrefr
= 0;
2564 S_SET_WEAKREFD (symbolS
*s
)
2566 if (s
->flags
.local_symbol
)
2567 s
= local_symbol_convert (s
);
2568 s
->flags
.weakrefd
= 1;
2573 S_CLEAR_WEAKREFD (symbolS
*s
)
2575 if (s
->flags
.local_symbol
)
2577 if (s
->flags
.weakrefd
)
2579 s
->flags
.weakrefd
= 0;
2580 /* If a weakref target symbol is weak, then it was never
2581 referenced directly before, not even in a .global directive,
2582 so decay it to local. If it remains undefined, it will be
2583 later turned into a global, like any other undefined
2585 if (s
->bsym
->flags
& BSF_WEAK
)
2587 #ifdef obj_clear_weak_hook
2588 obj_clear_weak_hook (s
);
2590 s
->bsym
->flags
&= ~BSF_WEAK
;
2591 s
->bsym
->flags
|= BSF_LOCAL
;
2597 S_SET_THREAD_LOCAL (symbolS
*s
)
2599 if (s
->flags
.local_symbol
)
2600 s
= local_symbol_convert (s
);
2601 if (bfd_is_com_section (s
->bsym
->section
)
2602 && (s
->bsym
->flags
& BSF_THREAD_LOCAL
) != 0)
2604 s
->bsym
->flags
|= BSF_THREAD_LOCAL
;
2605 if ((s
->bsym
->flags
& BSF_FUNCTION
) != 0)
2606 as_bad (_("Accessing function `%s' as thread-local object"),
2608 else if (! bfd_is_und_section (s
->bsym
->section
)
2609 && (s
->bsym
->section
->flags
& SEC_THREAD_LOCAL
) == 0)
2610 as_bad (_("Accessing `%s' as thread-local object"),
2615 S_SET_NAME (symbolS
*s
, const char *name
)
2618 if (s
->flags
.local_symbol
)
2620 s
->bsym
->name
= name
;
2624 S_SET_VOLATILE (symbolS
*s
)
2626 if (s
->flags
.local_symbol
)
2627 s
= local_symbol_convert (s
);
2628 s
->flags
.volatil
= 1;
2632 S_CLEAR_VOLATILE (symbolS
*s
)
2634 if (!s
->flags
.local_symbol
)
2635 s
->flags
.volatil
= 0;
2639 S_SET_FORWARD_REF (symbolS
*s
)
2641 if (s
->flags
.local_symbol
)
2642 s
= local_symbol_convert (s
);
2643 s
->flags
.forward_ref
= 1;
2646 /* Return the previous symbol in a chain. */
2649 symbol_previous (symbolS
*s
)
2651 if (s
->flags
.local_symbol
)
2653 return s
->x
->previous
;
2656 /* Return the next symbol in a chain. */
2659 symbol_next (symbolS
*s
)
2661 if (s
->flags
.local_symbol
)
2666 /* Return a pointer to the value of a symbol as an expression. */
2669 symbol_get_value_expression (symbolS
*s
)
2671 if (s
->flags
.local_symbol
)
2672 s
= local_symbol_convert (s
);
2673 return &s
->x
->value
;
2676 /* Set the value of a symbol to an expression. */
2679 symbol_set_value_expression (symbolS
*s
, const expressionS
*exp
)
2681 if (s
->flags
.local_symbol
)
2682 s
= local_symbol_convert (s
);
2684 S_CLEAR_WEAKREFR (s
);
2687 /* Return whether 2 symbols are the same. */
2690 symbol_same_p (symbolS
*s1
, symbolS
*s2
)
2695 /* Return a pointer to the X_add_number component of a symbol. */
2698 symbol_X_add_number (symbolS
*s
)
2700 if (s
->flags
.local_symbol
)
2701 return (offsetT
*) &((struct local_symbol
*) s
)->value
;
2703 return &s
->x
->value
.X_add_number
;
2706 /* Set the value of SYM to the current position in the current segment. */
2709 symbol_set_value_now (symbolS
*sym
)
2711 S_SET_SEGMENT (sym
, now_seg
);
2712 S_SET_VALUE (sym
, frag_now_fix ());
2713 symbol_set_frag (sym
, frag_now
);
2716 /* Set the frag of a symbol. */
2719 symbol_set_frag (symbolS
*s
, fragS
*f
)
2721 if (s
->flags
.local_symbol
)
2723 ((struct local_symbol
*) s
)->frag
= f
;
2727 S_CLEAR_WEAKREFR (s
);
2730 /* Return the frag of a symbol. */
2733 symbol_get_frag (symbolS
*s
)
2735 if (s
->flags
.local_symbol
)
2736 return ((struct local_symbol
*) s
)->frag
;
2740 /* Mark a symbol as having been used. */
2743 symbol_mark_used (symbolS
*s
)
2745 if (s
->flags
.local_symbol
)
2748 if (S_IS_WEAKREFR (s
))
2749 symbol_mark_used (s
->x
->value
.X_add_symbol
);
2752 /* Clear the mark of whether a symbol has been used. */
2755 symbol_clear_used (symbolS
*s
)
2757 if (s
->flags
.local_symbol
)
2758 s
= local_symbol_convert (s
);
2762 /* Return whether a symbol has been used. */
2765 symbol_used_p (symbolS
*s
)
2767 if (s
->flags
.local_symbol
)
2769 return s
->flags
.used
;
2772 /* Mark a symbol as having been used in a reloc. */
2775 symbol_mark_used_in_reloc (symbolS
*s
)
2777 if (s
->flags
.local_symbol
)
2778 s
= local_symbol_convert (s
);
2779 s
->flags
.used_in_reloc
= 1;
2782 /* Clear the mark of whether a symbol has been used in a reloc. */
2785 symbol_clear_used_in_reloc (symbolS
*s
)
2787 if (s
->flags
.local_symbol
)
2789 s
->flags
.used_in_reloc
= 0;
2792 /* Return whether a symbol has been used in a reloc. */
2795 symbol_used_in_reloc_p (symbolS
*s
)
2797 if (s
->flags
.local_symbol
)
2799 return s
->flags
.used_in_reloc
;
2802 /* Mark a symbol as an MRI common symbol. */
2805 symbol_mark_mri_common (symbolS
*s
)
2807 if (s
->flags
.local_symbol
)
2808 s
= local_symbol_convert (s
);
2809 s
->flags
.mri_common
= 1;
2812 /* Clear the mark of whether a symbol is an MRI common symbol. */
2815 symbol_clear_mri_common (symbolS
*s
)
2817 if (s
->flags
.local_symbol
)
2819 s
->flags
.mri_common
= 0;
2822 /* Return whether a symbol is an MRI common symbol. */
2825 symbol_mri_common_p (symbolS
*s
)
2827 if (s
->flags
.local_symbol
)
2829 return s
->flags
.mri_common
;
2832 /* Mark a symbol as having been written. */
2835 symbol_mark_written (symbolS
*s
)
2837 if (s
->flags
.local_symbol
)
2839 s
->flags
.written
= 1;
2842 /* Clear the mark of whether a symbol has been written. */
2845 symbol_clear_written (symbolS
*s
)
2847 if (s
->flags
.local_symbol
)
2849 s
->flags
.written
= 0;
2852 /* Return whether a symbol has been written. */
2855 symbol_written_p (symbolS
*s
)
2857 if (s
->flags
.local_symbol
)
2859 return s
->flags
.written
;
2862 /* Mark a symbol as to be removed. */
2865 symbol_mark_removed (symbolS
*s
)
2867 if (s
->flags
.local_symbol
)
2869 s
->flags
.removed
= 1;
2872 /* Return whether a symbol has been marked to be removed. */
2875 symbol_removed_p (symbolS
*s
)
2877 if (s
->flags
.local_symbol
)
2879 return s
->flags
.removed
;
2882 /* Mark a symbol has having been resolved. */
2885 symbol_mark_resolved (symbolS
*s
)
2887 s
->flags
.resolved
= 1;
2890 /* Return whether a symbol has been resolved. */
2893 symbol_resolved_p (symbolS
*s
)
2895 return s
->flags
.resolved
;
2898 /* Return whether a symbol is a section symbol. */
2901 symbol_section_p (symbolS
*s
)
2903 if (s
->flags
.local_symbol
)
2905 return (s
->bsym
->flags
& BSF_SECTION_SYM
) != 0;
2908 /* Return whether a symbol is equated to another symbol. */
2911 symbol_equated_p (symbolS
*s
)
2913 if (s
->flags
.local_symbol
)
2915 return s
->x
->value
.X_op
== O_symbol
;
2918 /* Return whether a symbol is equated to another symbol, and should be
2919 treated specially when writing out relocs. */
2922 symbol_equated_reloc_p (symbolS
*s
)
2924 if (s
->flags
.local_symbol
)
2926 /* X_op_symbol, normally not used for O_symbol, is set by
2927 resolve_symbol_value to flag expression syms that have been
2929 return (s
->x
->value
.X_op
== O_symbol
2930 #if defined (OBJ_COFF) && defined (TE_PE)
2933 && ((s
->flags
.resolved
&& s
->x
->value
.X_op_symbol
!= NULL
)
2934 || ! S_IS_DEFINED (s
)
2935 || S_IS_COMMON (s
)));
2938 /* Return whether a symbol has a constant value. */
2941 symbol_constant_p (symbolS
*s
)
2943 if (s
->flags
.local_symbol
)
2945 return s
->x
->value
.X_op
== O_constant
;
2948 /* Return whether a symbol was cloned and thus removed from the global
2952 symbol_shadow_p (symbolS
*s
)
2954 if (s
->flags
.local_symbol
)
2956 return s
->x
->next
== s
;
2959 /* If S is a struct symbol return S, otherwise return NULL. */
2962 symbol_symbolS (symbolS
*s
)
2964 if (s
->flags
.local_symbol
)
2969 /* Return the BFD symbol for a symbol. */
2972 symbol_get_bfdsym (symbolS
*s
)
2974 if (s
->flags
.local_symbol
)
2975 s
= local_symbol_convert (s
);
2979 /* Set the BFD symbol for a symbol. */
2982 symbol_set_bfdsym (symbolS
*s
, asymbol
*bsym
)
2984 if (s
->flags
.local_symbol
)
2985 s
= local_symbol_convert (s
);
2986 /* Usually, it is harmless to reset a symbol to a BFD section
2987 symbol. For example, obj_elf_change_section sets the BFD symbol
2988 of an old symbol with the newly created section symbol. But when
2989 we have multiple sections with the same name, the newly created
2990 section may have the same name as an old section. We check if the
2991 old symbol has been already marked as a section symbol before
2993 if ((s
->bsym
->flags
& BSF_SECTION_SYM
) == 0)
2995 /* else XXX - What do we do now ? */
2998 #ifdef OBJ_SYMFIELD_TYPE
3000 /* Get a pointer to the object format information for a symbol. */
3003 symbol_get_obj (symbolS
*s
)
3005 if (s
->flags
.local_symbol
)
3006 s
= local_symbol_convert (s
);
3010 /* Set the object format information for a symbol. */
3013 symbol_set_obj (symbolS
*s
, OBJ_SYMFIELD_TYPE
*o
)
3015 if (s
->flags
.local_symbol
)
3016 s
= local_symbol_convert (s
);
3020 #endif /* OBJ_SYMFIELD_TYPE */
3022 #ifdef TC_SYMFIELD_TYPE
3024 /* Get a pointer to the processor information for a symbol. */
3027 symbol_get_tc (symbolS
*s
)
3029 if (s
->flags
.local_symbol
)
3030 s
= local_symbol_convert (s
);
3034 /* Set the processor information for a symbol. */
3037 symbol_set_tc (symbolS
*s
, TC_SYMFIELD_TYPE
*o
)
3039 if (s
->flags
.local_symbol
)
3040 s
= local_symbol_convert (s
);
3044 #endif /* TC_SYMFIELD_TYPE */
3049 symbol_lastP
= NULL
;
3050 symbol_rootP
= NULL
; /* In case we have 0 symbols (!!) */
3051 sy_hash
= htab_create_alloc (16, hash_symbol_entry
, eq_symbol_entry
,
3052 NULL
, xcalloc
, free
);
3054 #if defined (EMIT_SECTION_SYMBOLS) || !defined (RELOC_REQUIRES_SYMBOL)
3055 abs_symbol
.bsym
= bfd_abs_section_ptr
->symbol
;
3057 abs_symbol
.x
= &abs_symbol_x
;
3058 abs_symbol
.x
->value
.X_op
= O_constant
;
3059 abs_symbol
.frag
= &zero_address_frag
;
3061 if (LOCAL_LABELS_FB
)
3068 htab_delete (sy_hash
);
3072 dot_symbol_init (void)
3074 dot_symbol
.name
= ".";
3075 dot_symbol
.flags
.forward_ref
= 1;
3076 dot_symbol
.bsym
= bfd_make_empty_symbol (stdoutput
);
3077 if (dot_symbol
.bsym
== NULL
)
3078 as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));
3079 dot_symbol
.bsym
->name
= ".";
3080 dot_symbol
.x
= &dot_symbol_x
;
3081 dot_symbol
.x
->value
.X_op
= O_constant
;
3086 /* Maximum indent level.
3087 Available for modification inside a gdb session. */
3088 static int max_indent_level
= 8;
3091 print_symbol_value_1 (FILE *file
, symbolS
*sym
)
3093 const char *name
= S_GET_NAME (sym
);
3094 if (!name
|| !name
[0])
3096 fprintf (file
, "sym ");
3097 fprintf_vma (file
, (bfd_vma
) (uintptr_t) sym
);
3098 fprintf (file
, " %s", name
);
3100 if (sym
->flags
.local_symbol
)
3102 struct local_symbol
*locsym
= (struct local_symbol
*) sym
;
3104 if (locsym
->frag
!= &zero_address_frag
3105 && locsym
->frag
!= NULL
)
3107 fprintf (file
, " frag ");
3108 fprintf_vma (file
, (bfd_vma
) (uintptr_t) locsym
->frag
);
3110 if (locsym
->flags
.resolved
)
3111 fprintf (file
, " resolved");
3112 fprintf (file
, " local");
3116 if (sym
->frag
!= &zero_address_frag
)
3118 fprintf (file
, " frag ");
3119 fprintf_vma (file
, (bfd_vma
) (uintptr_t) sym
->frag
);
3121 if (sym
->flags
.written
)
3122 fprintf (file
, " written");
3123 if (sym
->flags
.resolved
)
3124 fprintf (file
, " resolved");
3125 else if (sym
->flags
.resolving
)
3126 fprintf (file
, " resolving");
3127 if (sym
->flags
.used_in_reloc
)
3128 fprintf (file
, " used-in-reloc");
3129 if (sym
->flags
.used
)
3130 fprintf (file
, " used");
3131 if (S_IS_LOCAL (sym
))
3132 fprintf (file
, " local");
3133 if (S_IS_EXTERNAL (sym
))
3134 fprintf (file
, " extern");
3135 if (S_IS_WEAK (sym
))
3136 fprintf (file
, " weak");
3137 if (S_IS_DEBUG (sym
))
3138 fprintf (file
, " debug");
3139 if (S_IS_DEFINED (sym
))
3140 fprintf (file
, " defined");
3142 if (S_IS_WEAKREFR (sym
))
3143 fprintf (file
, " weakrefr");
3144 if (S_IS_WEAKREFD (sym
))
3145 fprintf (file
, " weakrefd");
3146 fprintf (file
, " %s", segment_name (S_GET_SEGMENT (sym
)));
3147 if (symbol_resolved_p (sym
))
3149 segT s
= S_GET_SEGMENT (sym
);
3151 if (s
!= undefined_section
3152 && s
!= expr_section
)
3153 fprintf (file
, " %lx", (unsigned long) S_GET_VALUE (sym
));
3155 else if (indent_level
< max_indent_level
3156 && S_GET_SEGMENT (sym
) != undefined_section
)
3159 fprintf (file
, "\n%*s<", indent_level
* 4, "");
3160 if (sym
->flags
.local_symbol
)
3161 fprintf (file
, "constant %lx",
3162 (unsigned long) ((struct local_symbol
*) sym
)->value
);
3164 print_expr_1 (file
, &sym
->x
->value
);
3165 fprintf (file
, ">");
3172 print_symbol_value (symbolS
*sym
)
3175 print_symbol_value_1 (stderr
, sym
);
3176 fprintf (stderr
, "\n");
3180 print_binary (FILE *file
, const char *name
, expressionS
*exp
)
3183 fprintf (file
, "%s\n%*s<", name
, indent_level
* 4, "");
3184 print_symbol_value_1 (file
, exp
->X_add_symbol
);
3185 fprintf (file
, ">\n%*s<", indent_level
* 4, "");
3186 print_symbol_value_1 (file
, exp
->X_op_symbol
);
3187 fprintf (file
, ">");
3192 print_expr_1 (FILE *file
, expressionS
*exp
)
3194 fprintf (file
, "expr ");
3195 fprintf_vma (file
, (bfd_vma
) (uintptr_t) exp
);
3196 fprintf (file
, " ");
3200 fprintf (file
, "illegal");
3203 fprintf (file
, "absent");
3206 fprintf (file
, "constant %lx", (unsigned long) exp
->X_add_number
);
3210 fprintf (file
, "symbol\n%*s<", indent_level
* 4, "");
3211 print_symbol_value_1 (file
, exp
->X_add_symbol
);
3212 fprintf (file
, ">");
3214 if (exp
->X_add_number
)
3215 fprintf (file
, "\n%*s%lx", indent_level
* 4, "",
3216 (unsigned long) exp
->X_add_number
);
3220 fprintf (file
, "register #%d", (int) exp
->X_add_number
);
3223 fprintf (file
, "big");
3226 fprintf (file
, "uminus -<");
3228 print_symbol_value_1 (file
, exp
->X_add_symbol
);
3229 fprintf (file
, ">");
3230 goto maybe_print_addnum
;
3232 fprintf (file
, "bit_not");
3235 print_binary (file
, "multiply", exp
);
3238 print_binary (file
, "divide", exp
);
3241 print_binary (file
, "modulus", exp
);
3244 print_binary (file
, "lshift", exp
);
3247 print_binary (file
, "rshift", exp
);
3249 case O_bit_inclusive_or
:
3250 print_binary (file
, "bit_ior", exp
);
3252 case O_bit_exclusive_or
:
3253 print_binary (file
, "bit_xor", exp
);
3256 print_binary (file
, "bit_and", exp
);
3259 print_binary (file
, "eq", exp
);
3262 print_binary (file
, "ne", exp
);
3265 print_binary (file
, "lt", exp
);
3268 print_binary (file
, "le", exp
);
3271 print_binary (file
, "ge", exp
);
3274 print_binary (file
, "gt", exp
);
3277 print_binary (file
, "logical_and", exp
);
3280 print_binary (file
, "logical_or", exp
);
3284 fprintf (file
, "add\n%*s<", indent_level
* 4, "");
3285 print_symbol_value_1 (file
, exp
->X_add_symbol
);
3286 fprintf (file
, ">\n%*s<", indent_level
* 4, "");
3287 print_symbol_value_1 (file
, exp
->X_op_symbol
);
3288 fprintf (file
, ">");
3289 goto maybe_print_addnum
;
3292 fprintf (file
, "subtract\n%*s<", indent_level
* 4, "");
3293 print_symbol_value_1 (file
, exp
->X_add_symbol
);
3294 fprintf (file
, ">\n%*s<", indent_level
* 4, "");
3295 print_symbol_value_1 (file
, exp
->X_op_symbol
);
3296 fprintf (file
, ">");
3297 goto maybe_print_addnum
;
3299 fprintf (file
, "{unknown opcode %d}", (int) exp
->X_op
);
3306 print_expr (expressionS
*exp
)
3308 print_expr_1 (stderr
, exp
);
3309 fprintf (stderr
, "\n");
3313 symbol_print_statistics (FILE *file
)
3315 htab_print_statistics (file
, "symbol table", sy_hash
);
3316 fprintf (file
, "%lu mini local symbols created, %lu converted\n",
3317 local_symbol_count
, local_symbol_conversion_count
);
3320 #ifdef OBJ_COMPLEX_RELC
3322 /* Convert given symbol to a new complex-relocation symbol name. This
3323 may be a recursive function, since it might be called for non-leaf
3324 nodes (plain symbols) in the expression tree. The caller owns the
3325 returning string, so should free it eventually. Errors are
3326 indicated via as_bad and a NULL return value. The given symbol
3327 is marked with used_in_reloc. */
3330 symbol_relc_make_sym (symbolS
* sym
)
3332 char * terminal
= NULL
;
3337 gas_assert (sym
!= NULL
);
3339 /* Recurse to symbol_relc_make_expr if this symbol
3340 is defined as an expression or a plain value. */
3341 if ( S_GET_SEGMENT (sym
) == expr_section
3342 || S_GET_SEGMENT (sym
) == absolute_section
)
3343 return symbol_relc_make_expr (symbol_get_value_expression (sym
));
3345 /* This may be a "fake symbol", referring to ".".
3346 Write out a special null symbol to refer to this position. */
3347 if (! strcmp (S_GET_NAME (sym
), FAKE_LABEL_NAME
))
3348 return xstrdup (".");
3350 /* We hope this is a plain leaf symbol. Construct the encoding
3351 as {S,s}II...:CCCCCCC....
3352 where 'S'/'s' means section symbol / plain symbol
3353 III is decimal for the symbol name length
3354 CCC is the symbol name itself. */
3355 symbol_mark_used_in_reloc (sym
);
3357 sname
= S_GET_NAME (sym
);
3358 sname_len
= strlen (sname
);
3359 typetag
= symbol_section_p (sym
) ? 'S' : 's';
3361 terminal
= XNEWVEC (char, (1 /* S or s */
3362 + 8 /* sname_len in decimal */
3364 + sname_len
/* name itself */
3367 sprintf (terminal
, "%c%d:%s", typetag
, sname_len
, sname
);
3371 /* Convert given value to a new complex-relocation symbol name. This
3372 is a non-recursive function, since it is be called for leaf nodes
3373 (plain values) in the expression tree. The caller owns the
3374 returning string, so should free() it eventually. No errors. */
3377 symbol_relc_make_value (offsetT val
)
3379 char * terminal
= XNEWVEC (char, 28); /* Enough for long long. */
3382 bfd_sprintf_vma (stdoutput
, terminal
+ 1, val
);
3386 /* Convert given expression to a new complex-relocation symbol name.
3387 This is a recursive function, since it traverses the entire given
3388 expression tree. The caller owns the returning string, so should
3389 free() it eventually. Errors are indicated via as_bad() and a NULL
3393 symbol_relc_make_expr (expressionS
* exp
)
3395 const char * opstr
= NULL
; /* Operator prefix string. */
3396 int arity
= 0; /* Arity of this operator. */
3397 char * operands
[3]; /* Up to three operands. */
3398 char * concat_string
= NULL
;
3400 operands
[0] = operands
[1] = operands
[2] = NULL
;
3402 gas_assert (exp
!= NULL
);
3404 /* Match known operators -> fill in opstr, arity, operands[] and fall
3405 through to construct subexpression fragments; may instead return
3406 string directly for leaf nodes. */
3408 /* See expr.h for the meaning of all these enums. Many operators
3409 have an unnatural arity (X_add_number implicitly added). The
3410 conversion logic expands them to explicit "+" subexpressions. */
3415 as_bad ("Unknown expression operator (enum %d)", exp
->X_op
);
3420 return symbol_relc_make_value (exp
->X_add_number
);
3423 if (exp
->X_add_number
)
3427 operands
[0] = symbol_relc_make_sym (exp
->X_add_symbol
);
3428 operands
[1] = symbol_relc_make_value (exp
->X_add_number
);
3432 return symbol_relc_make_sym (exp
->X_add_symbol
);
3434 /* Helper macros for nesting nodes. */
3436 #define HANDLE_XADD_OPT1(str_) \
3437 if (exp->X_add_number) \
3440 opstr = "+:" str_; \
3441 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3442 operands[1] = symbol_relc_make_value (exp->X_add_number); \
3449 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3453 #define HANDLE_XADD_OPT2(str_) \
3454 if (exp->X_add_number) \
3457 opstr = "+:" str_; \
3458 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3459 operands[1] = symbol_relc_make_sym (exp->X_op_symbol); \
3460 operands[2] = symbol_relc_make_value (exp->X_add_number); \
3466 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3467 operands[1] = symbol_relc_make_sym (exp->X_op_symbol); \
3471 /* Nesting nodes. */
3473 case O_uminus
: HANDLE_XADD_OPT1 ("0-");
3474 case O_bit_not
: HANDLE_XADD_OPT1 ("~");
3475 case O_logical_not
: HANDLE_XADD_OPT1 ("!");
3476 case O_multiply
: HANDLE_XADD_OPT2 ("*");
3477 case O_divide
: HANDLE_XADD_OPT2 ("/");
3478 case O_modulus
: HANDLE_XADD_OPT2 ("%");
3479 case O_left_shift
: HANDLE_XADD_OPT2 ("<<");
3480 case O_right_shift
: HANDLE_XADD_OPT2 (">>");
3481 case O_bit_inclusive_or
: HANDLE_XADD_OPT2 ("|");
3482 case O_bit_exclusive_or
: HANDLE_XADD_OPT2 ("^");
3483 case O_bit_and
: HANDLE_XADD_OPT2 ("&");
3484 case O_add
: HANDLE_XADD_OPT2 ("+");
3485 case O_subtract
: HANDLE_XADD_OPT2 ("-");
3486 case O_eq
: HANDLE_XADD_OPT2 ("==");
3487 case O_ne
: HANDLE_XADD_OPT2 ("!=");
3488 case O_lt
: HANDLE_XADD_OPT2 ("<");
3489 case O_le
: HANDLE_XADD_OPT2 ("<=");
3490 case O_ge
: HANDLE_XADD_OPT2 (">=");
3491 case O_gt
: HANDLE_XADD_OPT2 (">");
3492 case O_logical_and
: HANDLE_XADD_OPT2 ("&&");
3493 case O_logical_or
: HANDLE_XADD_OPT2 ("||");
3496 /* Validate & reject early. */
3497 if (arity
>= 1 && ((operands
[0] == NULL
) || (strlen (operands
[0]) == 0)))
3499 if (arity
>= 2 && ((operands
[1] == NULL
) || (strlen (operands
[1]) == 0)))
3501 if (arity
>= 3 && ((operands
[2] == NULL
) || (strlen (operands
[2]) == 0)))
3505 concat_string
= NULL
;
3506 else if (arity
== 0)
3507 concat_string
= xstrdup (opstr
);
3508 else if (arity
== 1)
3509 concat_string
= concat (opstr
, ":", operands
[0], (char *) NULL
);
3510 else if (arity
== 2)
3511 concat_string
= concat (opstr
, ":", operands
[0], ":", operands
[1],
3514 concat_string
= concat (opstr
, ":", operands
[0], ":", operands
[1], ":",
3515 operands
[2], (char *) NULL
);
3517 /* Free operand strings (not opstr). */
3518 if (arity
>= 1) xfree (operands
[0]);
3519 if (arity
>= 2) xfree (operands
[1]);
3520 if (arity
>= 3) xfree (operands
[2]);
3522 return concat_string
;