1 /* symbols.c -symbol table-
2 Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
4 Free Software Foundation, Inc.
6 This file is part of GAS, the GNU Assembler.
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GAS is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
23 /* #define DEBUG_SYMS / * to debug symbol list maintenance. */
27 #include "safe-ctype.h"
28 #include "obstack.h" /* For "symbols.h" */
31 #include "struc-symbol.h"
33 /* This is non-zero if symbols are case sensitive, which is the
35 int symbols_case_sensitive
= 1;
37 #ifndef WORKING_DOT_WORD
38 extern int new_broken_words
;
41 /* symbol-name => struct symbol pointer */
42 static struct hash_control
*sy_hash
;
44 /* Table of local symbols. */
45 static struct hash_control
*local_hash
;
47 /* Below are commented in "symbols.h". */
48 symbolS
*symbol_rootP
;
49 symbolS
*symbol_lastP
;
53 #define debug_verify_symchain verify_symbol_chain
55 #define debug_verify_symchain(root, last) ((void) 0)
58 #define DOLLAR_LABEL_CHAR '\001'
59 #define LOCAL_LABEL_CHAR '\002'
63 /* The name of an external symbol which is
64 used to make weak PE symbol names unique. */
65 const char * an_external_name
;
68 static char *save_symbol_name (const char *);
69 static void fb_label_init (void);
70 static long dollar_label_instance (long);
71 static long fb_label_instance (long);
73 static void print_binary (FILE *, const char *, expressionS
*);
74 static void report_op_error (symbolS
*, symbolS
*, symbolS
*);
76 /* Return a pointer to a new symbol. Die if we can't make a new
77 symbol. Fill in the symbol's values. Add symbol to end of symbol
80 This function should be called in the general case of creating a
81 symbol. However, if the output file symbol table has already been
82 set, and you are certain that this symbol won't be wanted in the
83 output file, you can call symbol_create. */
86 symbol_new (const char *name
, segT segment
, valueT valu
, fragS
*frag
)
88 symbolS
*symbolP
= symbol_create (name
, segment
, valu
, frag
);
90 /* Link to end of symbol chain. */
92 extern int symbol_table_frozen
;
93 if (symbol_table_frozen
)
96 symbol_append (symbolP
, symbol_lastP
, &symbol_rootP
, &symbol_lastP
);
101 /* Save a symbol name on a permanent obstack, and convert it according
102 to the object file format. */
105 save_symbol_name (const char *name
)
107 unsigned int name_length
;
110 name_length
= strlen (name
) + 1; /* +1 for \0. */
111 obstack_grow (¬es
, name
, name_length
);
112 ret
= obstack_finish (¬es
);
114 #ifdef tc_canonicalize_symbol_name
115 ret
= tc_canonicalize_symbol_name (ret
);
118 if (! symbols_case_sensitive
)
122 for (s
= ret
; *s
!= '\0'; s
++)
130 symbol_create (const char *name
, /* It is copied, the caller can destroy/modify. */
131 segT segment
, /* Segment identifier (SEG_<something>). */
132 valueT valu
, /* Symbol value. */
133 fragS
*frag
/* Associated fragment. */)
135 char *preserved_copy_of_name
;
138 preserved_copy_of_name
= save_symbol_name (name
);
140 symbolP
= (symbolS
*) obstack_alloc (¬es
, sizeof (symbolS
));
142 /* symbol must be born in some fixed state. This seems as good as any. */
143 memset (symbolP
, 0, sizeof (symbolS
));
145 symbolP
->bsym
= bfd_make_empty_symbol (stdoutput
);
146 if (symbolP
->bsym
== NULL
)
147 as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));
148 S_SET_NAME (symbolP
, preserved_copy_of_name
);
150 S_SET_SEGMENT (symbolP
, segment
);
151 S_SET_VALUE (symbolP
, valu
);
152 symbol_clear_list_pointers (symbolP
);
154 symbolP
->sy_frag
= frag
;
156 obj_symbol_new_hook (symbolP
);
158 #ifdef tc_symbol_new_hook
159 tc_symbol_new_hook (symbolP
);
166 /* Local symbol support. If we can get away with it, we keep only a
167 small amount of information for local symbols. */
169 static symbolS
*local_symbol_convert (struct local_symbol
*);
171 /* Used for statistics. */
173 static unsigned long local_symbol_count
;
174 static unsigned long local_symbol_conversion_count
;
176 /* This macro is called with a symbol argument passed by reference.
177 It returns whether this is a local symbol. If necessary, it
178 changes its argument to the real symbol. */
180 #define LOCAL_SYMBOL_CHECK(s) \
182 ? (local_symbol_converted_p ((struct local_symbol *) s) \
183 ? (s = local_symbol_get_real_symbol ((struct local_symbol *) s), \
188 /* Create a local symbol and insert it into the local hash table. */
190 static struct local_symbol
*
191 local_symbol_make (const char *name
, segT section
, valueT value
, fragS
*frag
)
194 struct local_symbol
*ret
;
196 ++local_symbol_count
;
198 name_copy
= save_symbol_name (name
);
200 ret
= (struct local_symbol
*) obstack_alloc (¬es
, sizeof *ret
);
201 ret
->lsy_marker
= NULL
;
202 ret
->lsy_name
= name_copy
;
203 ret
->lsy_section
= section
;
204 local_symbol_set_frag (ret
, frag
);
205 ret
->lsy_value
= value
;
207 hash_jam (local_hash
, name_copy
, (PTR
) ret
);
212 /* Convert a local symbol into a real symbol. Note that we do not
213 reclaim the space used by the local symbol. */
216 local_symbol_convert (struct local_symbol
*locsym
)
220 assert (locsym
->lsy_marker
== NULL
);
221 if (local_symbol_converted_p (locsym
))
222 return local_symbol_get_real_symbol (locsym
);
224 ++local_symbol_conversion_count
;
226 ret
= symbol_new (locsym
->lsy_name
, locsym
->lsy_section
, locsym
->lsy_value
,
227 local_symbol_get_frag (locsym
));
229 if (local_symbol_resolved_p (locsym
))
230 ret
->sy_resolved
= 1;
232 /* Local symbols are always either defined or used. */
235 #ifdef TC_LOCAL_SYMFIELD_CONVERT
236 TC_LOCAL_SYMFIELD_CONVERT (locsym
, ret
);
239 symbol_table_insert (ret
);
241 local_symbol_mark_converted (locsym
);
242 local_symbol_set_real_symbol (locsym
, ret
);
244 hash_jam (local_hash
, locsym
->lsy_name
, NULL
);
249 /* We have just seen "<name>:".
250 Creates a struct symbol unless it already exists.
252 Gripes if we are redefining a symbol incompatibly (and ignores it). */
255 colon (/* Just seen "x:" - rattle symbols & frags. */
256 const char *sym_name
/* Symbol name, as a cannonical string. */
257 /* We copy this string: OK to alter later. */)
259 register symbolS
*symbolP
; /* Symbol we are working with. */
261 /* Sun local labels go out of scope whenever a non-local symbol is
263 if (LOCAL_LABELS_DOLLAR
264 && !bfd_is_local_label_name (stdoutput
, sym_name
))
265 dollar_label_clear ();
267 #ifndef WORKING_DOT_WORD
268 if (new_broken_words
)
270 struct broken_word
*a
;
275 if (now_seg
== absolute_section
)
277 as_bad (_("cannot define symbol `%s' in absolute section"), sym_name
);
281 possible_bytes
= (md_short_jump_size
282 + new_broken_words
* md_long_jump_size
);
285 frag_opcode
= frag_var (rs_broken_word
,
289 (symbolS
*) broken_words
,
293 /* We want to store the pointer to where to insert the jump
294 table in the fr_opcode of the rs_broken_word frag. This
295 requires a little hackery. */
297 && (frag_tmp
->fr_type
!= rs_broken_word
298 || frag_tmp
->fr_opcode
))
299 frag_tmp
= frag_tmp
->fr_next
;
301 frag_tmp
->fr_opcode
= frag_opcode
;
302 new_broken_words
= 0;
304 for (a
= broken_words
; a
&& a
->dispfrag
== 0; a
= a
->next_broken_word
)
305 a
->dispfrag
= frag_tmp
;
307 #endif /* WORKING_DOT_WORD */
309 if ((symbolP
= symbol_find (sym_name
)) != 0)
311 S_CLEAR_WEAKREFR (symbolP
);
312 #ifdef RESOLVE_SYMBOL_REDEFINITION
313 if (RESOLVE_SYMBOL_REDEFINITION (symbolP
))
316 /* Now check for undefined symbols. */
317 if (LOCAL_SYMBOL_CHECK (symbolP
))
319 struct local_symbol
*locsym
= (struct local_symbol
*) symbolP
;
321 if (locsym
->lsy_section
!= undefined_section
322 && (local_symbol_get_frag (locsym
) != frag_now
323 || locsym
->lsy_section
!= now_seg
324 || locsym
->lsy_value
!= frag_now_fix ()))
326 as_bad (_("symbol `%s' is already defined"), sym_name
);
330 locsym
->lsy_section
= now_seg
;
331 local_symbol_set_frag (locsym
, frag_now
);
332 locsym
->lsy_value
= frag_now_fix ();
334 else if (!(S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
335 || S_IS_COMMON (symbolP
)
336 || S_IS_VOLATILE (symbolP
))
338 if (S_IS_VOLATILE (symbolP
))
340 symbolP
= symbol_clone (symbolP
, 1);
341 S_SET_VALUE (symbolP
, 0);
342 S_CLEAR_VOLATILE (symbolP
);
344 if (S_GET_VALUE (symbolP
) == 0)
346 symbolP
->sy_frag
= frag_now
;
348 S_SET_OTHER (symbolP
, const_flag
);
350 S_SET_VALUE (symbolP
, (valueT
) frag_now_fix ());
351 S_SET_SEGMENT (symbolP
, now_seg
);
354 #endif /* if we have one, it better be zero. */
359 /* There are still several cases to check:
361 A .comm/.lcomm symbol being redefined as initialized
364 A .comm/.lcomm symbol being redefined with a larger
367 This only used to be allowed on VMS gas, but Sun cc
368 on the sparc also depends on it. */
370 if (((!S_IS_DEBUG (symbolP
)
371 && (!S_IS_DEFINED (symbolP
) || S_IS_COMMON (symbolP
))
372 && S_IS_EXTERNAL (symbolP
))
373 || S_GET_SEGMENT (symbolP
) == bss_section
)
374 && (now_seg
== data_section
375 || now_seg
== bss_section
376 || now_seg
== S_GET_SEGMENT (symbolP
)))
378 /* Select which of the 2 cases this is. */
379 if (now_seg
!= data_section
)
381 /* New .comm for prev .comm symbol.
383 If the new size is larger we just change its
384 value. If the new size is smaller, we ignore
386 if (S_GET_VALUE (symbolP
)
387 < ((unsigned) frag_now_fix ()))
389 S_SET_VALUE (symbolP
, (valueT
) frag_now_fix ());
394 /* It is a .comm/.lcomm being converted to initialized
396 symbolP
->sy_frag
= frag_now
;
398 S_SET_OTHER (symbolP
, const_flag
);
400 S_SET_VALUE (symbolP
, (valueT
) frag_now_fix ());
401 S_SET_SEGMENT (symbolP
, now_seg
); /* Keep N_EXT bit. */
406 #if (!defined (OBJ_AOUT) && !defined (OBJ_MAYBE_AOUT) \
407 && !defined (OBJ_BOUT) && !defined (OBJ_MAYBE_BOUT))
408 static const char *od_buf
= "";
412 if (OUTPUT_FLAVOR
== bfd_target_aout_flavour
)
413 sprintf (od_buf
, "%d.%d.",
414 S_GET_OTHER (symbolP
),
415 S_GET_DESC (symbolP
));
417 as_bad (_("symbol `%s' is already defined as \"%s\"/%s%ld"),
419 segment_name (S_GET_SEGMENT (symbolP
)),
421 (long) S_GET_VALUE (symbolP
));
423 } /* if the undefined symbol has no value */
427 /* Don't blow up if the definition is the same. */
428 if (!(frag_now
== symbolP
->sy_frag
429 && S_GET_VALUE (symbolP
) == frag_now_fix ()
430 && S_GET_SEGMENT (symbolP
) == now_seg
))
432 as_bad (_("symbol `%s' is already defined"), sym_name
);
433 symbolP
= symbol_clone (symbolP
, 0);
438 else if (! flag_keep_locals
&& bfd_is_local_label_name (stdoutput
, sym_name
))
440 symbolP
= (symbolS
*) local_symbol_make (sym_name
, now_seg
,
441 (valueT
) frag_now_fix (),
446 symbolP
= symbol_new (sym_name
, now_seg
, (valueT
) frag_now_fix (),
449 S_SET_OTHER (symbolP
, const_flag
);
452 symbol_table_insert (symbolP
);
455 if (mri_common_symbol
!= NULL
)
457 /* This symbol is actually being defined within an MRI common
458 section. This requires special handling. */
459 if (LOCAL_SYMBOL_CHECK (symbolP
))
460 symbolP
= local_symbol_convert ((struct local_symbol
*) symbolP
);
461 symbolP
->sy_value
.X_op
= O_symbol
;
462 symbolP
->sy_value
.X_add_symbol
= mri_common_symbol
;
463 symbolP
->sy_value
.X_add_number
= S_GET_VALUE (mri_common_symbol
);
464 symbolP
->sy_frag
= &zero_address_frag
;
465 S_SET_SEGMENT (symbolP
, expr_section
);
466 symbolP
->sy_mri_common
= 1;
470 tc_frob_label (symbolP
);
472 #ifdef obj_frob_label
473 obj_frob_label (symbolP
);
479 /* Die if we can't insert the symbol. */
482 symbol_table_insert (symbolS
*symbolP
)
484 register const char *error_string
;
487 know (S_GET_NAME (symbolP
));
489 if (LOCAL_SYMBOL_CHECK (symbolP
))
491 error_string
= hash_jam (local_hash
, S_GET_NAME (symbolP
),
493 if (error_string
!= NULL
)
494 as_fatal (_("inserting \"%s\" into symbol table failed: %s"),
495 S_GET_NAME (symbolP
), error_string
);
499 if ((error_string
= hash_jam (sy_hash
, S_GET_NAME (symbolP
), (PTR
) symbolP
)))
501 as_fatal (_("inserting \"%s\" into symbol table failed: %s"),
502 S_GET_NAME (symbolP
), error_string
);
506 /* If a symbol name does not exist, create it as undefined, and insert
507 it into the symbol table. Return a pointer to it. */
510 symbol_find_or_make (const char *name
)
512 register symbolS
*symbolP
;
514 symbolP
= symbol_find (name
);
518 if (! flag_keep_locals
&& bfd_is_local_label_name (stdoutput
, name
))
520 symbolP
= md_undefined_symbol ((char *) name
);
524 symbolP
= (symbolS
*) local_symbol_make (name
, undefined_section
,
530 symbolP
= symbol_make (name
);
532 symbol_table_insert (symbolP
);
533 } /* if symbol wasn't found */
539 symbol_make (const char *name
)
543 /* Let the machine description default it, e.g. for register names. */
544 symbolP
= md_undefined_symbol ((char *) name
);
547 symbolP
= symbol_new (name
, undefined_section
, (valueT
) 0, &zero_address_frag
);
553 symbol_clone (symbolS
*orgsymP
, int replace
)
556 asymbol
*bsymorg
, *bsymnew
;
558 /* Running local_symbol_convert on a clone that's not the one currently
559 in local_hash would incorrectly replace the hash entry. Thus the
560 symbol must be converted here. Note that the rest of the function
561 depends on not encountering an unconverted symbol. */
562 if (LOCAL_SYMBOL_CHECK (orgsymP
))
563 orgsymP
= local_symbol_convert ((struct local_symbol
*) orgsymP
);
564 bsymorg
= orgsymP
->bsym
;
566 know (S_IS_DEFINED (orgsymP
));
568 newsymP
= obstack_alloc (¬es
, sizeof (*newsymP
));
570 bsymnew
= bfd_make_empty_symbol (bfd_asymbol_bfd (bsymorg
));
572 as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));
573 newsymP
->bsym
= bsymnew
;
574 bsymnew
->name
= bsymorg
->name
;
575 bsymnew
->flags
= bsymorg
->flags
;
576 bsymnew
->section
= bsymorg
->section
;
577 bfd_copy_private_symbol_data (bfd_asymbol_bfd (bsymorg
), bsymorg
,
578 bfd_asymbol_bfd (bsymnew
), bsymnew
);
580 #ifdef obj_symbol_clone_hook
581 obj_symbol_clone_hook (newsymP
, orgsymP
);
584 #ifdef tc_symbol_clone_hook
585 tc_symbol_clone_hook (newsymP
, orgsymP
);
590 if (symbol_rootP
== orgsymP
)
591 symbol_rootP
= newsymP
;
592 else if (orgsymP
->sy_previous
)
594 orgsymP
->sy_previous
->sy_next
= newsymP
;
595 orgsymP
->sy_previous
= NULL
;
597 if (symbol_lastP
== orgsymP
)
598 symbol_lastP
= newsymP
;
599 else if (orgsymP
->sy_next
)
600 orgsymP
->sy_next
->sy_previous
= newsymP
;
601 orgsymP
->sy_next
= NULL
;
602 debug_verify_symchain (symbol_rootP
, symbol_lastP
);
604 symbol_table_insert (newsymP
);
610 /* Referenced symbols, if they are forward references, need to be cloned
611 (without replacing the original) so that the value of the referenced
612 symbols at the point of use . */
614 #undef symbol_clone_if_forward_ref
616 symbol_clone_if_forward_ref (symbolS
*symbolP
, int is_forward
)
618 if (symbolP
&& !LOCAL_SYMBOL_CHECK (symbolP
))
620 symbolS
*add_symbol
= symbolP
->sy_value
.X_add_symbol
;
621 symbolS
*op_symbol
= symbolP
->sy_value
.X_op_symbol
;
623 if (symbolP
->sy_forward_ref
)
628 /* assign_symbol() clones volatile symbols; pre-existing expressions
629 hold references to the original instance, but want the current
630 value. Just repeat the lookup. */
631 if (add_symbol
&& S_IS_VOLATILE (add_symbol
))
632 add_symbol
= symbol_find_exact (S_GET_NAME (add_symbol
));
633 if (op_symbol
&& S_IS_VOLATILE (op_symbol
))
634 op_symbol
= symbol_find_exact (S_GET_NAME (op_symbol
));
637 /* Re-using sy_resolving here, as this routine cannot get called from
638 symbol resolution code. */
639 if (symbolP
->bsym
->section
== expr_section
&& !symbolP
->sy_resolving
)
641 symbolP
->sy_resolving
= 1;
642 add_symbol
= symbol_clone_if_forward_ref (add_symbol
, is_forward
);
643 op_symbol
= symbol_clone_if_forward_ref (op_symbol
, is_forward
);
644 symbolP
->sy_resolving
= 0;
647 if (symbolP
->sy_forward_ref
648 || add_symbol
!= symbolP
->sy_value
.X_add_symbol
649 || op_symbol
!= symbolP
->sy_value
.X_op_symbol
)
650 symbolP
= symbol_clone (symbolP
, 0);
652 symbolP
->sy_value
.X_add_symbol
= add_symbol
;
653 symbolP
->sy_value
.X_op_symbol
= op_symbol
;
660 symbol_temp_new (segT seg
, valueT ofs
, fragS
*frag
)
662 return symbol_new (FAKE_LABEL_NAME
, seg
, ofs
, frag
);
666 symbol_temp_new_now (void)
668 return symbol_temp_new (now_seg
, frag_now_fix (), frag_now
);
672 symbol_temp_make (void)
674 return symbol_make (FAKE_LABEL_NAME
);
677 /* Implement symbol table lookup.
678 In: A symbol's name as a string: '\0' can't be part of a symbol name.
679 Out: NULL if the name was not in the symbol table, else the address
680 of a struct symbol associated with that name. */
683 symbol_find_exact (const char *name
)
685 return symbol_find_exact_noref (name
, 0);
689 symbol_find_exact_noref (const char *name
, int noref
)
691 struct local_symbol
*locsym
;
694 locsym
= (struct local_symbol
*) hash_find (local_hash
, name
);
696 return (symbolS
*) locsym
;
698 sym
= ((symbolS
*) hash_find (sy_hash
, name
));
700 /* Any references to the symbol, except for the reference in
701 .weakref, must clear this flag, such that the symbol does not
702 turn into a weak symbol. Note that we don't have to handle the
703 local_symbol case, since a weakrefd is always promoted out of the
704 local_symbol table when it is turned into a weak symbol. */
706 S_CLEAR_WEAKREFD (sym
);
712 symbol_find (const char *name
)
714 return symbol_find_noref (name
, 0);
718 symbol_find_noref (const char *name
, int noref
)
720 #ifdef tc_canonicalize_symbol_name
723 size_t len
= strlen (name
) + 1;
725 copy
= (char *) alloca (len
);
726 memcpy (copy
, name
, len
);
727 name
= tc_canonicalize_symbol_name (copy
);
731 if (! symbols_case_sensitive
)
738 name
= copy
= (char *) alloca (strlen (name
) + 1);
740 while ((c
= *orig
++) != '\0')
742 *copy
++ = TOUPPER (c
);
747 return symbol_find_exact_noref (name
, noref
);
750 /* Once upon a time, symbols were kept in a singly linked list. At
751 least coff needs to be able to rearrange them from time to time, for
752 which a doubly linked list is much more convenient. Loic did these
753 as macros which seemed dangerous to me so they're now functions.
756 /* Link symbol ADDME after symbol TARGET in the chain. */
759 symbol_append (symbolS
*addme
, symbolS
*target
,
760 symbolS
**rootPP
, symbolS
**lastPP
)
762 if (LOCAL_SYMBOL_CHECK (addme
))
764 if (target
!= NULL
&& LOCAL_SYMBOL_CHECK (target
))
769 know (*rootPP
== NULL
);
770 know (*lastPP
== NULL
);
771 addme
->sy_next
= NULL
;
772 addme
->sy_previous
= NULL
;
776 } /* if the list is empty */
778 if (target
->sy_next
!= NULL
)
780 target
->sy_next
->sy_previous
= addme
;
784 know (*lastPP
== target
);
786 } /* if we have a next */
788 addme
->sy_next
= target
->sy_next
;
789 target
->sy_next
= addme
;
790 addme
->sy_previous
= target
;
792 debug_verify_symchain (symbol_rootP
, symbol_lastP
);
795 /* Set the chain pointers of SYMBOL to null. */
798 symbol_clear_list_pointers (symbolS
*symbolP
)
800 if (LOCAL_SYMBOL_CHECK (symbolP
))
802 symbolP
->sy_next
= NULL
;
803 symbolP
->sy_previous
= NULL
;
806 /* Remove SYMBOLP from the list. */
809 symbol_remove (symbolS
*symbolP
, symbolS
**rootPP
, symbolS
**lastPP
)
811 if (LOCAL_SYMBOL_CHECK (symbolP
))
814 if (symbolP
== *rootPP
)
816 *rootPP
= symbolP
->sy_next
;
817 } /* if it was the root */
819 if (symbolP
== *lastPP
)
821 *lastPP
= symbolP
->sy_previous
;
822 } /* if it was the tail */
824 if (symbolP
->sy_next
!= NULL
)
826 symbolP
->sy_next
->sy_previous
= symbolP
->sy_previous
;
829 if (symbolP
->sy_previous
!= NULL
)
831 symbolP
->sy_previous
->sy_next
= symbolP
->sy_next
;
834 debug_verify_symchain (*rootPP
, *lastPP
);
837 /* Link symbol ADDME before symbol TARGET in the chain. */
840 symbol_insert (symbolS
*addme
, symbolS
*target
,
841 symbolS
**rootPP
, symbolS
**lastPP ATTRIBUTE_UNUSED
)
843 if (LOCAL_SYMBOL_CHECK (addme
))
845 if (LOCAL_SYMBOL_CHECK (target
))
848 if (target
->sy_previous
!= NULL
)
850 target
->sy_previous
->sy_next
= addme
;
854 know (*rootPP
== target
);
858 addme
->sy_previous
= target
->sy_previous
;
859 target
->sy_previous
= addme
;
860 addme
->sy_next
= target
;
862 debug_verify_symchain (*rootPP
, *lastPP
);
866 verify_symbol_chain (symbolS
*rootP
, symbolS
*lastP
)
868 symbolS
*symbolP
= rootP
;
873 for (; symbol_next (symbolP
) != NULL
; symbolP
= symbol_next (symbolP
))
875 assert (symbolP
->bsym
!= NULL
);
876 assert (symbolP
->sy_next
->sy_previous
== symbolP
);
879 assert (lastP
== symbolP
);
883 report_op_error (symbolS
*symp
, symbolS
*left
, symbolS
*right
)
887 segT seg_left
= S_GET_SEGMENT (left
);
888 segT seg_right
= right
? S_GET_SEGMENT (right
) : 0;
890 if (expr_symbol_where (symp
, &file
, &line
))
892 if (seg_left
== undefined_section
)
893 as_bad_where (file
, line
,
894 _("undefined symbol `%s' in operation"),
896 if (seg_right
== undefined_section
)
897 as_bad_where (file
, line
,
898 _("undefined symbol `%s' in operation"),
900 if (seg_left
!= undefined_section
901 && seg_right
!= undefined_section
)
904 as_bad_where (file
, line
,
905 _("invalid sections for operation on `%s' and `%s'"),
906 S_GET_NAME (left
), S_GET_NAME (right
));
908 as_bad_where (file
, line
,
909 _("invalid section for operation on `%s'"),
916 if (seg_left
== undefined_section
)
917 as_bad (_("undefined symbol `%s' in operation setting `%s'"),
918 S_GET_NAME (left
), S_GET_NAME (symp
));
919 if (seg_right
== undefined_section
)
920 as_bad (_("undefined symbol `%s' in operation setting `%s'"),
921 S_GET_NAME (right
), S_GET_NAME (symp
));
922 if (seg_left
!= undefined_section
923 && seg_right
!= undefined_section
)
926 as_bad (_("invalid sections for operation on `%s' and `%s' setting `%s'"),
927 S_GET_NAME (left
), S_GET_NAME (right
), S_GET_NAME (symp
));
929 as_bad (_("invalid section for operation on `%s' setting `%s'"),
930 S_GET_NAME (left
), S_GET_NAME (symp
));
935 /* Resolve the value of a symbol. This is called during the final
936 pass over the symbol table to resolve any symbols with complex
940 resolve_symbol_value (symbolS
*symp
)
943 valueT final_val
= 0;
946 if (LOCAL_SYMBOL_CHECK (symp
))
948 struct local_symbol
*locsym
= (struct local_symbol
*) symp
;
950 final_val
= locsym
->lsy_value
;
951 if (local_symbol_resolved_p (locsym
))
954 final_val
+= local_symbol_get_frag (locsym
)->fr_address
/ OCTETS_PER_BYTE
;
958 locsym
->lsy_value
= final_val
;
959 local_symbol_mark_resolved (locsym
);
965 if (symp
->sy_resolved
)
967 if (symp
->sy_value
.X_op
== O_constant
)
968 return (valueT
) symp
->sy_value
.X_add_number
;
974 final_seg
= S_GET_SEGMENT (symp
);
976 if (symp
->sy_resolving
)
979 as_bad (_("symbol definition loop encountered at `%s'"),
986 symbolS
*add_symbol
, *op_symbol
;
988 segT seg_left
, seg_right
;
992 symp
->sy_resolving
= 1;
994 /* Help out with CSE. */
995 add_symbol
= symp
->sy_value
.X_add_symbol
;
996 op_symbol
= symp
->sy_value
.X_op_symbol
;
997 final_val
= symp
->sy_value
.X_add_number
;
998 op
= symp
->sy_value
.X_op
;
1011 final_val
+= symp
->sy_frag
->fr_address
/ OCTETS_PER_BYTE
;
1012 if (final_seg
== expr_section
)
1013 final_seg
= absolute_section
;
1019 left
= resolve_symbol_value (add_symbol
);
1020 seg_left
= S_GET_SEGMENT (add_symbol
);
1022 symp
->sy_value
.X_op_symbol
= NULL
;
1025 if (S_IS_WEAKREFR (symp
))
1027 assert (final_val
== 0);
1028 if (S_IS_WEAKREFR (add_symbol
))
1030 assert (add_symbol
->sy_value
.X_op
== O_symbol
1031 && add_symbol
->sy_value
.X_add_number
== 0);
1032 add_symbol
= add_symbol
->sy_value
.X_add_symbol
;
1033 assert (! S_IS_WEAKREFR (add_symbol
));
1034 symp
->sy_value
.X_add_symbol
= add_symbol
;
1038 if (symp
->sy_mri_common
)
1040 /* This is a symbol inside an MRI common section. The
1041 relocation routines are going to handle it specially.
1042 Don't change the value. */
1043 resolved
= symbol_resolved_p (add_symbol
);
1047 if (finalize_syms
&& final_val
== 0)
1049 if (LOCAL_SYMBOL_CHECK (add_symbol
))
1050 add_symbol
= local_symbol_convert ((struct local_symbol
*)
1052 copy_symbol_attributes (symp
, add_symbol
);
1055 /* If we have equated this symbol to an undefined or common
1056 symbol, keep X_op set to O_symbol, and don't change
1057 X_add_number. This permits the routine which writes out
1058 relocation to detect this case, and convert the
1059 relocation to be against the symbol to which this symbol
1061 if (! S_IS_DEFINED (add_symbol
)
1062 #if defined (OBJ_COFF) && defined (TE_PE)
1063 || S_IS_WEAK (add_symbol
)
1065 || S_IS_COMMON (add_symbol
))
1069 symp
->sy_value
.X_op
= O_symbol
;
1070 symp
->sy_value
.X_add_symbol
= add_symbol
;
1071 symp
->sy_value
.X_add_number
= final_val
;
1072 /* Use X_op_symbol as a flag. */
1073 symp
->sy_value
.X_op_symbol
= add_symbol
;
1074 final_seg
= seg_left
;
1077 resolved
= symbol_resolved_p (add_symbol
);
1078 symp
->sy_resolving
= 0;
1079 goto exit_dont_set_value
;
1081 else if (finalize_syms
&& final_seg
== expr_section
1082 && seg_left
!= expr_section
)
1084 /* If the symbol is an expression symbol, do similarly
1085 as for undefined and common syms above. Handles
1086 "sym +/- expr" where "expr" cannot be evaluated
1087 immediately, and we want relocations to be against
1088 "sym", eg. because it is weak. */
1089 symp
->sy_value
.X_op
= O_symbol
;
1090 symp
->sy_value
.X_add_symbol
= add_symbol
;
1091 symp
->sy_value
.X_add_number
= final_val
;
1092 symp
->sy_value
.X_op_symbol
= add_symbol
;
1093 final_seg
= seg_left
;
1094 final_val
+= symp
->sy_frag
->fr_address
+ left
;
1095 resolved
= symbol_resolved_p (add_symbol
);
1096 symp
->sy_resolving
= 0;
1097 goto exit_dont_set_value
;
1101 final_val
+= symp
->sy_frag
->fr_address
+ left
;
1102 if (final_seg
== expr_section
|| final_seg
== undefined_section
)
1103 final_seg
= seg_left
;
1106 resolved
= symbol_resolved_p (add_symbol
);
1107 if (S_IS_WEAKREFR (symp
))
1108 goto exit_dont_set_value
;
1114 left
= resolve_symbol_value (add_symbol
);
1115 seg_left
= S_GET_SEGMENT (add_symbol
);
1117 /* By reducing these to the relevant dyadic operator, we get
1118 !S -> S == 0 permitted on anything,
1119 -S -> 0 - S only permitted on absolute
1120 ~S -> S ^ ~0 only permitted on absolute */
1121 if (op
!= O_logical_not
&& seg_left
!= absolute_section
1123 report_op_error (symp
, add_symbol
, NULL
);
1125 if (final_seg
== expr_section
|| final_seg
== undefined_section
)
1126 final_seg
= absolute_section
;
1130 else if (op
== O_logical_not
)
1135 final_val
+= left
+ symp
->sy_frag
->fr_address
;
1137 resolved
= symbol_resolved_p (add_symbol
);
1145 case O_bit_inclusive_or
:
1147 case O_bit_exclusive_or
:
1159 left
= resolve_symbol_value (add_symbol
);
1160 right
= resolve_symbol_value (op_symbol
);
1161 seg_left
= S_GET_SEGMENT (add_symbol
);
1162 seg_right
= S_GET_SEGMENT (op_symbol
);
1164 /* Simplify addition or subtraction of a constant by folding the
1165 constant into X_add_number. */
1168 if (seg_right
== absolute_section
)
1173 else if (seg_left
== absolute_section
)
1176 add_symbol
= op_symbol
;
1178 seg_left
= seg_right
;
1182 else if (op
== O_subtract
)
1184 if (seg_right
== absolute_section
)
1192 /* Equality and non-equality tests are permitted on anything.
1193 Subtraction, and other comparison operators are permitted if
1194 both operands are in the same section. Otherwise, both
1195 operands must be absolute. We already handled the case of
1196 addition or subtraction of a constant above. This will
1197 probably need to be changed for an object file format which
1198 supports arbitrary expressions, such as IEEE-695. */
1199 if (!(seg_left
== absolute_section
1200 && seg_right
== absolute_section
)
1201 && !(op
== O_eq
|| op
== O_ne
)
1202 && !((op
== O_subtract
1203 || op
== O_lt
|| op
== O_le
|| op
== O_ge
|| op
== O_gt
)
1204 && seg_left
== seg_right
1205 && (seg_left
!= undefined_section
1206 || add_symbol
== op_symbol
)))
1208 /* Don't emit messages unless we're finalizing the symbol value,
1209 otherwise we may get the same message multiple times. */
1211 report_op_error (symp
, add_symbol
, op_symbol
);
1212 /* However do not move the symbol into the absolute section
1213 if it cannot currently be resolved - this would confuse
1214 other parts of the assembler into believing that the
1215 expression had been evaluated to zero. */
1221 && (final_seg
== expr_section
|| final_seg
== undefined_section
))
1222 final_seg
= absolute_section
;
1224 /* Check for division by zero. */
1225 if ((op
== O_divide
|| op
== O_modulus
) && right
== 0)
1227 /* If seg_right is not absolute_section, then we've
1228 already issued a warning about using a bad symbol. */
1229 if (seg_right
== absolute_section
&& finalize_syms
)
1234 if (expr_symbol_where (symp
, &file
, &line
))
1235 as_bad_where (file
, line
, _("division by zero"));
1237 as_bad (_("division by zero when setting `%s'"),
1244 switch (symp
->sy_value
.X_op
)
1246 case O_multiply
: left
*= right
; break;
1247 case O_divide
: left
/= right
; break;
1248 case O_modulus
: left
%= right
; break;
1249 case O_left_shift
: left
<<= right
; break;
1250 case O_right_shift
: left
>>= right
; break;
1251 case O_bit_inclusive_or
: left
|= right
; break;
1252 case O_bit_or_not
: left
|= ~right
; break;
1253 case O_bit_exclusive_or
: left
^= right
; break;
1254 case O_bit_and
: left
&= right
; break;
1255 case O_add
: left
+= right
; break;
1256 case O_subtract
: left
-= right
; break;
1259 left
= (left
== right
&& seg_left
== seg_right
1260 && (seg_left
!= undefined_section
1261 || add_symbol
== op_symbol
)
1262 ? ~ (offsetT
) 0 : 0);
1263 if (symp
->sy_value
.X_op
== O_ne
)
1266 case O_lt
: left
= left
< right
? ~ (offsetT
) 0 : 0; break;
1267 case O_le
: left
= left
<= right
? ~ (offsetT
) 0 : 0; break;
1268 case O_ge
: left
= left
>= right
? ~ (offsetT
) 0 : 0; break;
1269 case O_gt
: left
= left
> right
? ~ (offsetT
) 0 : 0; break;
1270 case O_logical_and
: left
= left
&& right
; break;
1271 case O_logical_or
: left
= left
|| right
; break;
1275 final_val
+= symp
->sy_frag
->fr_address
+ left
;
1276 if (final_seg
== expr_section
|| final_seg
== undefined_section
)
1278 if (seg_left
== undefined_section
1279 || seg_right
== undefined_section
)
1280 final_seg
= undefined_section
;
1281 else if (seg_left
== absolute_section
)
1282 final_seg
= seg_right
;
1284 final_seg
= seg_left
;
1286 resolved
= (symbol_resolved_p (add_symbol
)
1287 && symbol_resolved_p (op_symbol
));
1293 /* Give an error (below) if not in expr_section. We don't
1294 want to worry about expr_section symbols, because they
1295 are fictional (they are created as part of expression
1296 resolution), and any problems may not actually mean
1301 symp
->sy_resolving
= 0;
1305 S_SET_VALUE (symp
, final_val
);
1307 exit_dont_set_value
:
1308 /* Always set the segment, even if not finalizing the value.
1309 The segment is used to determine whether a symbol is defined. */
1310 S_SET_SEGMENT (symp
, final_seg
);
1312 /* Don't worry if we can't resolve an expr_section symbol. */
1316 symp
->sy_resolved
= 1;
1317 else if (S_GET_SEGMENT (symp
) != expr_section
)
1319 as_bad (_("can't resolve value for symbol `%s'"),
1321 symp
->sy_resolved
= 1;
1328 static void resolve_local_symbol (const char *, PTR
);
1330 /* A static function passed to hash_traverse. */
1333 resolve_local_symbol (const char *key ATTRIBUTE_UNUSED
, PTR value
)
1336 resolve_symbol_value (value
);
1339 /* Resolve all local symbols. */
1342 resolve_local_symbol_values (void)
1344 hash_traverse (local_hash
, resolve_local_symbol
);
1347 /* Obtain the current value of a symbol without changing any
1348 sub-expressions used. */
1351 snapshot_symbol (symbolS
**symbolPP
, valueT
*valueP
, segT
*segP
, fragS
**fragPP
)
1353 symbolS
*symbolP
= *symbolPP
;
1355 if (LOCAL_SYMBOL_CHECK (symbolP
))
1357 struct local_symbol
*locsym
= (struct local_symbol
*) symbolP
;
1359 *valueP
= locsym
->lsy_value
;
1360 *segP
= locsym
->lsy_section
;
1361 *fragPP
= local_symbol_get_frag (locsym
);
1365 expressionS expr
= symbolP
->sy_value
;
1367 if (!symbolP
->sy_resolved
&& expr
.X_op
!= O_illegal
)
1371 if (symbolP
->sy_resolving
)
1373 symbolP
->sy_resolving
= 1;
1374 resolved
= resolve_expression (&expr
);
1375 symbolP
->sy_resolving
= 0;
1383 if (!symbol_equated_p (symbolP
))
1388 symbolP
= expr
.X_add_symbol
;
1395 /* Never change a defined symbol. */
1396 if (symbolP
->bsym
->section
== undefined_section
1397 || symbolP
->bsym
->section
== expr_section
)
1398 *symbolPP
= symbolP
;
1399 *valueP
= expr
.X_add_number
;
1400 *segP
= symbolP
->bsym
->section
;
1401 *fragPP
= symbolP
->sy_frag
;
1403 if (*segP
== expr_section
)
1406 case O_constant
: *segP
= absolute_section
; break;
1407 case O_register
: *segP
= reg_section
; break;
1415 /* Dollar labels look like a number followed by a dollar sign. Eg, "42$".
1416 They are *really* local. That is, they go out of scope whenever we see a
1417 label that isn't local. Also, like fb labels, there can be multiple
1418 instances of a dollar label. Therefor, we name encode each instance with
1419 the instance number, keep a list of defined symbols separate from the real
1420 symbol table, and we treat these buggers as a sparse array. */
1422 static long *dollar_labels
;
1423 static long *dollar_label_instances
;
1424 static char *dollar_label_defines
;
1425 static unsigned long dollar_label_count
;
1426 static unsigned long dollar_label_max
;
1429 dollar_label_defined (long label
)
1433 know ((dollar_labels
!= NULL
) || (dollar_label_count
== 0));
1435 for (i
= dollar_labels
; i
< dollar_labels
+ dollar_label_count
; ++i
)
1437 return dollar_label_defines
[i
- dollar_labels
];
1439 /* If we get here, label isn't defined. */
1444 dollar_label_instance (long label
)
1448 know ((dollar_labels
!= NULL
) || (dollar_label_count
== 0));
1450 for (i
= dollar_labels
; i
< dollar_labels
+ dollar_label_count
; ++i
)
1452 return (dollar_label_instances
[i
- dollar_labels
]);
1454 /* If we get here, we haven't seen the label before.
1455 Therefore its instance count is zero. */
1460 dollar_label_clear (void)
1462 memset (dollar_label_defines
, '\0', (unsigned int) dollar_label_count
);
1465 #define DOLLAR_LABEL_BUMP_BY 10
1468 define_dollar_label (long label
)
1472 for (i
= dollar_labels
; i
< dollar_labels
+ dollar_label_count
; ++i
)
1475 ++dollar_label_instances
[i
- dollar_labels
];
1476 dollar_label_defines
[i
- dollar_labels
] = 1;
1480 /* If we get to here, we don't have label listed yet. */
1482 if (dollar_labels
== NULL
)
1484 dollar_labels
= (long *) xmalloc (DOLLAR_LABEL_BUMP_BY
* sizeof (long));
1485 dollar_label_instances
= (long *) xmalloc (DOLLAR_LABEL_BUMP_BY
* sizeof (long));
1486 dollar_label_defines
= xmalloc (DOLLAR_LABEL_BUMP_BY
);
1487 dollar_label_max
= DOLLAR_LABEL_BUMP_BY
;
1488 dollar_label_count
= 0;
1490 else if (dollar_label_count
== dollar_label_max
)
1492 dollar_label_max
+= DOLLAR_LABEL_BUMP_BY
;
1493 dollar_labels
= (long *) xrealloc ((char *) dollar_labels
,
1494 dollar_label_max
* sizeof (long));
1495 dollar_label_instances
= (long *) xrealloc ((char *) dollar_label_instances
,
1496 dollar_label_max
* sizeof (long));
1497 dollar_label_defines
= xrealloc (dollar_label_defines
, dollar_label_max
);
1498 } /* if we needed to grow */
1500 dollar_labels
[dollar_label_count
] = label
;
1501 dollar_label_instances
[dollar_label_count
] = 1;
1502 dollar_label_defines
[dollar_label_count
] = 1;
1503 ++dollar_label_count
;
1506 /* Caller must copy returned name: we re-use the area for the next name.
1508 The mth occurence of label n: is turned into the symbol "Ln^Am"
1509 where n is the label number and m is the instance number. "L" makes
1510 it a label discarded unless debugging and "^A"('\1') ensures no
1511 ordinary symbol SHOULD get the same name as a local label
1512 symbol. The first "4:" is "L4^A1" - the m numbers begin at 1.
1514 fb labels get the same treatment, except that ^B is used in place
1517 char * /* Return local label name. */
1518 dollar_label_name (register long n
, /* we just saw "n$:" : n a number. */
1519 register int augend
/* 0 for current instance, 1 for new instance. */)
1522 /* Returned to caller, then copied. Used for created names ("4f"). */
1523 static char symbol_name_build
[24];
1526 char symbol_name_temporary
[20]; /* Build up a number, BACKWARDS. */
1529 know (augend
== 0 || augend
== 1);
1530 p
= symbol_name_build
;
1531 #ifdef LOCAL_LABEL_PREFIX
1532 *p
++ = LOCAL_LABEL_PREFIX
;
1536 /* Next code just does sprintf( {}, "%d", n); */
1538 q
= symbol_name_temporary
;
1539 for (*q
++ = 0, i
= n
; i
; ++q
)
1544 while ((*p
= *--q
) != '\0')
1547 *p
++ = DOLLAR_LABEL_CHAR
; /* ^A */
1549 /* Instance number. */
1550 q
= symbol_name_temporary
;
1551 for (*q
++ = 0, i
= dollar_label_instance (n
) + augend
; i
; ++q
)
1556 while ((*p
++ = *--q
) != '\0');;
1558 /* The label, as a '\0' ended string, starts at symbol_name_build. */
1559 return symbol_name_build
;
1562 /* Somebody else's idea of local labels. They are made by "n:" where n
1563 is any decimal digit. Refer to them with
1564 "nb" for previous (backward) n:
1565 or "nf" for next (forward) n:.
1567 We do a little better and let n be any number, not just a single digit, but
1568 since the other guy's assembler only does ten, we treat the first ten
1571 Like someone else's assembler, we have one set of local label counters for
1572 entire assembly, not one set per (sub)segment like in most assemblers. This
1573 implies that one can refer to a label in another segment, and indeed some
1574 crufty compilers have done just that.
1576 Since there could be a LOT of these things, treat them as a sparse
1579 #define FB_LABEL_SPECIAL (10)
1581 static long fb_low_counter
[FB_LABEL_SPECIAL
];
1582 static long *fb_labels
;
1583 static long *fb_label_instances
;
1584 static long fb_label_count
;
1585 static long fb_label_max
;
1587 /* This must be more than FB_LABEL_SPECIAL. */
1588 #define FB_LABEL_BUMP_BY (FB_LABEL_SPECIAL + 6)
1591 fb_label_init (void)
1593 memset ((void *) fb_low_counter
, '\0', sizeof (fb_low_counter
));
1596 /* Add one to the instance number of this fb label. */
1599 fb_label_instance_inc (long label
)
1603 if (label
< FB_LABEL_SPECIAL
)
1605 ++fb_low_counter
[label
];
1609 if (fb_labels
!= NULL
)
1611 for (i
= fb_labels
+ FB_LABEL_SPECIAL
;
1612 i
< fb_labels
+ fb_label_count
; ++i
)
1616 ++fb_label_instances
[i
- fb_labels
];
1618 } /* if we find it */
1619 } /* for each existing label */
1622 /* If we get to here, we don't have label listed yet. */
1624 if (fb_labels
== NULL
)
1626 fb_labels
= (long *) xmalloc (FB_LABEL_BUMP_BY
* sizeof (long));
1627 fb_label_instances
= (long *) xmalloc (FB_LABEL_BUMP_BY
* sizeof (long));
1628 fb_label_max
= FB_LABEL_BUMP_BY
;
1629 fb_label_count
= FB_LABEL_SPECIAL
;
1632 else if (fb_label_count
== fb_label_max
)
1634 fb_label_max
+= FB_LABEL_BUMP_BY
;
1635 fb_labels
= (long *) xrealloc ((char *) fb_labels
,
1636 fb_label_max
* sizeof (long));
1637 fb_label_instances
= (long *) xrealloc ((char *) fb_label_instances
,
1638 fb_label_max
* sizeof (long));
1639 } /* if we needed to grow */
1641 fb_labels
[fb_label_count
] = label
;
1642 fb_label_instances
[fb_label_count
] = 1;
1647 fb_label_instance (long label
)
1651 if (label
< FB_LABEL_SPECIAL
)
1653 return (fb_low_counter
[label
]);
1656 if (fb_labels
!= NULL
)
1658 for (i
= fb_labels
+ FB_LABEL_SPECIAL
;
1659 i
< fb_labels
+ fb_label_count
; ++i
)
1663 return (fb_label_instances
[i
- fb_labels
]);
1664 } /* if we find it */
1665 } /* for each existing label */
1668 /* We didn't find the label, so this must be a reference to the
1673 /* Caller must copy returned name: we re-use the area for the next name.
1675 The mth occurence of label n: is turned into the symbol "Ln^Bm"
1676 where n is the label number and m is the instance number. "L" makes
1677 it a label discarded unless debugging and "^B"('\2') ensures no
1678 ordinary symbol SHOULD get the same name as a local label
1679 symbol. The first "4:" is "L4^B1" - the m numbers begin at 1.
1681 dollar labels get the same treatment, except that ^A is used in
1684 char * /* Return local label name. */
1685 fb_label_name (long n
, /* We just saw "n:", "nf" or "nb" : n a number. */
1686 long augend
/* 0 for nb, 1 for n:, nf. */)
1689 /* Returned to caller, then copied. Used for created names ("4f"). */
1690 static char symbol_name_build
[24];
1693 char symbol_name_temporary
[20]; /* Build up a number, BACKWARDS. */
1697 know ((unsigned long) augend
<= 2 /* See mmix_fb_label. */);
1699 know ((unsigned long) augend
<= 1);
1701 p
= symbol_name_build
;
1702 #ifdef LOCAL_LABEL_PREFIX
1703 *p
++ = LOCAL_LABEL_PREFIX
;
1707 /* Next code just does sprintf( {}, "%d", n); */
1709 q
= symbol_name_temporary
;
1710 for (*q
++ = 0, i
= n
; i
; ++q
)
1715 while ((*p
= *--q
) != '\0')
1718 *p
++ = LOCAL_LABEL_CHAR
; /* ^B */
1720 /* Instance number. */
1721 q
= symbol_name_temporary
;
1722 for (*q
++ = 0, i
= fb_label_instance (n
) + augend
; i
; ++q
)
1727 while ((*p
++ = *--q
) != '\0');;
1729 /* The label, as a '\0' ended string, starts at symbol_name_build. */
1730 return (symbol_name_build
);
1733 /* Decode name that may have been generated by foo_label_name() above.
1734 If the name wasn't generated by foo_label_name(), then return it
1735 unaltered. This is used for error messages. */
1738 decode_local_label_name (char *s
)
1741 char *symbol_decode
;
1743 int instance_number
;
1745 const char *message_format
;
1748 #ifdef LOCAL_LABEL_PREFIX
1749 if (s
[index
] == LOCAL_LABEL_PREFIX
)
1753 if (s
[index
] != 'L')
1756 for (label_number
= 0, p
= s
+ index
+ 1; ISDIGIT (*p
); ++p
)
1757 label_number
= (10 * label_number
) + *p
- '0';
1759 if (*p
== DOLLAR_LABEL_CHAR
)
1761 else if (*p
== LOCAL_LABEL_CHAR
)
1766 for (instance_number
= 0, p
++; ISDIGIT (*p
); ++p
)
1767 instance_number
= (10 * instance_number
) + *p
- '0';
1769 message_format
= _("\"%d\" (instance number %d of a %s label)");
1770 symbol_decode
= obstack_alloc (¬es
, strlen (message_format
) + 30);
1771 sprintf (symbol_decode
, message_format
, label_number
, instance_number
, type
);
1773 return symbol_decode
;
1776 /* Get the value of a symbol. */
1779 S_GET_VALUE (symbolS
*s
)
1781 if (LOCAL_SYMBOL_CHECK (s
))
1782 return resolve_symbol_value (s
);
1784 if (!s
->sy_resolved
)
1786 valueT val
= resolve_symbol_value (s
);
1790 if (S_IS_WEAKREFR (s
))
1791 return S_GET_VALUE (s
->sy_value
.X_add_symbol
);
1793 if (s
->sy_value
.X_op
!= O_constant
)
1795 if (! s
->sy_resolved
1796 || s
->sy_value
.X_op
!= O_symbol
1797 || (S_IS_DEFINED (s
) && ! S_IS_COMMON (s
)))
1798 as_bad (_("attempt to get value of unresolved symbol `%s'"),
1801 return (valueT
) s
->sy_value
.X_add_number
;
1804 /* Set the value of a symbol. */
1807 S_SET_VALUE (symbolS
*s
, valueT val
)
1809 if (LOCAL_SYMBOL_CHECK (s
))
1811 ((struct local_symbol
*) s
)->lsy_value
= val
;
1815 s
->sy_value
.X_op
= O_constant
;
1816 s
->sy_value
.X_add_number
= (offsetT
) val
;
1817 s
->sy_value
.X_unsigned
= 0;
1818 S_CLEAR_WEAKREFR (s
);
1822 copy_symbol_attributes (symbolS
*dest
, symbolS
*src
)
1824 if (LOCAL_SYMBOL_CHECK (dest
))
1825 dest
= local_symbol_convert ((struct local_symbol
*) dest
);
1826 if (LOCAL_SYMBOL_CHECK (src
))
1827 src
= local_symbol_convert ((struct local_symbol
*) src
);
1829 /* In an expression, transfer the settings of these flags.
1830 The user can override later, of course. */
1831 #define COPIED_SYMFLAGS (BSF_FUNCTION | BSF_OBJECT)
1832 dest
->bsym
->flags
|= src
->bsym
->flags
& COPIED_SYMFLAGS
;
1834 #ifdef OBJ_COPY_SYMBOL_ATTRIBUTES
1835 OBJ_COPY_SYMBOL_ATTRIBUTES (dest
, src
);
1840 S_IS_FUNCTION (symbolS
*s
)
1844 if (LOCAL_SYMBOL_CHECK (s
))
1847 flags
= s
->bsym
->flags
;
1849 return (flags
& BSF_FUNCTION
) != 0;
1853 S_IS_EXTERNAL (symbolS
*s
)
1857 if (LOCAL_SYMBOL_CHECK (s
))
1860 flags
= s
->bsym
->flags
;
1863 if ((flags
& BSF_LOCAL
) && (flags
& BSF_GLOBAL
))
1866 return (flags
& BSF_GLOBAL
) != 0;
1870 S_IS_WEAK (symbolS
*s
)
1872 if (LOCAL_SYMBOL_CHECK (s
))
1874 /* Conceptually, a weakrefr is weak if the referenced symbol is. We
1875 could probably handle a WEAKREFR as always weak though. E.g., if
1876 the referenced symbol has lost its weak status, there's no reason
1877 to keep handling the weakrefr as if it was weak. */
1878 if (S_IS_WEAKREFR (s
))
1879 return S_IS_WEAK (s
->sy_value
.X_add_symbol
);
1880 return (s
->bsym
->flags
& BSF_WEAK
) != 0;
1884 S_IS_WEAKREFR (symbolS
*s
)
1886 if (LOCAL_SYMBOL_CHECK (s
))
1888 return s
->sy_weakrefr
!= 0;
1892 S_IS_WEAKREFD (symbolS
*s
)
1894 if (LOCAL_SYMBOL_CHECK (s
))
1896 return s
->sy_weakrefd
!= 0;
1900 S_IS_COMMON (symbolS
*s
)
1902 if (LOCAL_SYMBOL_CHECK (s
))
1904 return bfd_is_com_section (s
->bsym
->section
);
1908 S_IS_DEFINED (symbolS
*s
)
1910 if (LOCAL_SYMBOL_CHECK (s
))
1911 return ((struct local_symbol
*) s
)->lsy_section
!= undefined_section
;
1912 return s
->bsym
->section
!= undefined_section
;
1916 #ifndef EXTERN_FORCE_RELOC
1917 #define EXTERN_FORCE_RELOC IS_ELF
1920 /* Return true for symbols that should not be reduced to section
1921 symbols or eliminated from expressions, because they may be
1922 overridden by the linker. */
1924 S_FORCE_RELOC (symbolS
*s
, int strict
)
1926 if (LOCAL_SYMBOL_CHECK (s
))
1927 return ((struct local_symbol
*) s
)->lsy_section
== undefined_section
;
1930 && ((s
->bsym
->flags
& BSF_WEAK
) != 0
1931 || (EXTERN_FORCE_RELOC
1932 && (s
->bsym
->flags
& BSF_GLOBAL
) != 0)))
1933 || s
->bsym
->section
== undefined_section
1934 || bfd_is_com_section (s
->bsym
->section
));
1938 S_IS_DEBUG (symbolS
*s
)
1940 if (LOCAL_SYMBOL_CHECK (s
))
1942 if (s
->bsym
->flags
& BSF_DEBUGGING
)
1948 S_IS_LOCAL (symbolS
*s
)
1953 if (LOCAL_SYMBOL_CHECK (s
))
1956 flags
= s
->bsym
->flags
;
1959 if ((flags
& BSF_LOCAL
) && (flags
& BSF_GLOBAL
))
1962 if (bfd_get_section (s
->bsym
) == reg_section
)
1965 if (flag_strip_local_absolute
1966 /* Keep BSF_FILE symbols in order to allow debuggers to identify
1967 the source file even when the object file is stripped. */
1968 && (flags
& (BSF_GLOBAL
| BSF_FILE
)) == 0
1969 && bfd_get_section (s
->bsym
) == absolute_section
)
1972 name
= S_GET_NAME (s
);
1973 return (name
!= NULL
1975 && (strchr (name
, DOLLAR_LABEL_CHAR
)
1976 || strchr (name
, LOCAL_LABEL_CHAR
)
1977 || (! flag_keep_locals
1978 && (bfd_is_local_label (stdoutput
, s
->bsym
)
1981 && name
[1] == '?')))));
1985 S_IS_STABD (symbolS
*s
)
1987 return S_GET_NAME (s
) == 0;
1991 S_IS_VOLATILE (const symbolS
*s
)
1993 if (LOCAL_SYMBOL_CHECK (s
))
1995 return s
->sy_volatile
;
1999 S_IS_FORWARD_REF (const symbolS
*s
)
2001 if (LOCAL_SYMBOL_CHECK (s
))
2003 return s
->sy_forward_ref
;
2007 S_GET_NAME (symbolS
*s
)
2009 if (LOCAL_SYMBOL_CHECK (s
))
2010 return ((struct local_symbol
*) s
)->lsy_name
;
2011 return s
->bsym
->name
;
2015 S_GET_SEGMENT (symbolS
*s
)
2017 if (LOCAL_SYMBOL_CHECK (s
))
2018 return ((struct local_symbol
*) s
)->lsy_section
;
2019 return s
->bsym
->section
;
2023 S_SET_SEGMENT (symbolS
*s
, segT seg
)
2025 /* Don't reassign section symbols. The direct reason is to prevent seg
2026 faults assigning back to const global symbols such as *ABS*, but it
2027 shouldn't happen anyway. */
2029 if (LOCAL_SYMBOL_CHECK (s
))
2031 if (seg
== reg_section
)
2032 s
= local_symbol_convert ((struct local_symbol
*) s
);
2035 ((struct local_symbol
*) s
)->lsy_section
= seg
;
2040 if (s
->bsym
->flags
& BSF_SECTION_SYM
)
2042 if (s
->bsym
->section
!= seg
)
2046 s
->bsym
->section
= seg
;
2050 S_SET_EXTERNAL (symbolS
*s
)
2052 if (LOCAL_SYMBOL_CHECK (s
))
2053 s
= local_symbol_convert ((struct local_symbol
*) s
);
2054 if ((s
->bsym
->flags
& BSF_WEAK
) != 0)
2056 /* Let .weak override .global. */
2059 if (s
->bsym
->flags
& BSF_SECTION_SYM
)
2064 /* Do not reassign section symbols. */
2065 as_where (& file
, & line
);
2066 as_warn_where (file
, line
,
2067 _("section symbols are already global"));
2070 s
->bsym
->flags
|= BSF_GLOBAL
;
2071 s
->bsym
->flags
&= ~(BSF_LOCAL
| BSF_WEAK
);
2074 if (! an_external_name
&& S_GET_NAME(s
)[0] != '.')
2075 an_external_name
= S_GET_NAME (s
);
2080 S_CLEAR_EXTERNAL (symbolS
*s
)
2082 if (LOCAL_SYMBOL_CHECK (s
))
2084 if ((s
->bsym
->flags
& BSF_WEAK
) != 0)
2086 /* Let .weak override. */
2089 s
->bsym
->flags
|= BSF_LOCAL
;
2090 s
->bsym
->flags
&= ~(BSF_GLOBAL
| BSF_WEAK
);
2094 S_SET_WEAK (symbolS
*s
)
2096 if (LOCAL_SYMBOL_CHECK (s
))
2097 s
= local_symbol_convert ((struct local_symbol
*) s
);
2098 #ifdef obj_set_weak_hook
2099 obj_set_weak_hook (s
);
2101 s
->bsym
->flags
|= BSF_WEAK
;
2102 s
->bsym
->flags
&= ~(BSF_GLOBAL
| BSF_LOCAL
);
2106 S_SET_WEAKREFR (symbolS
*s
)
2108 if (LOCAL_SYMBOL_CHECK (s
))
2109 s
= local_symbol_convert ((struct local_symbol
*) s
);
2111 /* If the alias was already used, make sure we mark the target as
2112 used as well, otherwise it might be dropped from the symbol
2113 table. This may have unintended side effects if the alias is
2114 later redirected to another symbol, such as keeping the unused
2115 previous target in the symbol table. Since it will be weak, it's
2118 symbol_mark_used (s
->sy_value
.X_add_symbol
);
2122 S_CLEAR_WEAKREFR (symbolS
*s
)
2124 if (LOCAL_SYMBOL_CHECK (s
))
2130 S_SET_WEAKREFD (symbolS
*s
)
2132 if (LOCAL_SYMBOL_CHECK (s
))
2133 s
= local_symbol_convert ((struct local_symbol
*) s
);
2139 S_CLEAR_WEAKREFD (symbolS
*s
)
2141 if (LOCAL_SYMBOL_CHECK (s
))
2146 /* If a weakref target symbol is weak, then it was never
2147 referenced directly before, not even in a .global directive,
2148 so decay it to local. If it remains undefined, it will be
2149 later turned into a global, like any other undefined
2151 if (s
->bsym
->flags
& BSF_WEAK
)
2153 #ifdef obj_clear_weak_hook
2154 obj_clear_weak_hook (s
);
2156 s
->bsym
->flags
&= ~BSF_WEAK
;
2157 s
->bsym
->flags
|= BSF_LOCAL
;
2163 S_SET_THREAD_LOCAL (symbolS
*s
)
2165 if (LOCAL_SYMBOL_CHECK (s
))
2166 s
= local_symbol_convert ((struct local_symbol
*) s
);
2167 if (bfd_is_com_section (s
->bsym
->section
)
2168 && (s
->bsym
->flags
& BSF_THREAD_LOCAL
) != 0)
2170 s
->bsym
->flags
|= BSF_THREAD_LOCAL
;
2171 if ((s
->bsym
->flags
& BSF_FUNCTION
) != 0)
2172 as_bad (_("Accessing function `%s' as thread-local object"),
2174 else if (! bfd_is_und_section (s
->bsym
->section
)
2175 && (s
->bsym
->section
->flags
& SEC_THREAD_LOCAL
) == 0)
2176 as_bad (_("Accessing `%s' as thread-local object"),
2181 S_SET_NAME (symbolS
*s
, const char *name
)
2183 if (LOCAL_SYMBOL_CHECK (s
))
2185 ((struct local_symbol
*) s
)->lsy_name
= name
;
2188 s
->bsym
->name
= name
;
2192 S_SET_VOLATILE (symbolS
*s
)
2194 if (LOCAL_SYMBOL_CHECK (s
))
2195 s
= local_symbol_convert ((struct local_symbol
*) s
);
2200 S_CLEAR_VOLATILE (symbolS
*s
)
2202 if (!LOCAL_SYMBOL_CHECK (s
))
2207 S_SET_FORWARD_REF (symbolS
*s
)
2209 if (LOCAL_SYMBOL_CHECK (s
))
2210 s
= local_symbol_convert ((struct local_symbol
*) s
);
2211 s
->sy_forward_ref
= 1;
2214 /* Return the previous symbol in a chain. */
2217 symbol_previous (symbolS
*s
)
2219 if (LOCAL_SYMBOL_CHECK (s
))
2221 return s
->sy_previous
;
2224 /* Return the next symbol in a chain. */
2227 symbol_next (symbolS
*s
)
2229 if (LOCAL_SYMBOL_CHECK (s
))
2234 /* Return a pointer to the value of a symbol as an expression. */
2237 symbol_get_value_expression (symbolS
*s
)
2239 if (LOCAL_SYMBOL_CHECK (s
))
2240 s
= local_symbol_convert ((struct local_symbol
*) s
);
2241 return &s
->sy_value
;
2244 /* Set the value of a symbol to an expression. */
2247 symbol_set_value_expression (symbolS
*s
, const expressionS
*exp
)
2249 if (LOCAL_SYMBOL_CHECK (s
))
2250 s
= local_symbol_convert ((struct local_symbol
*) s
);
2252 S_CLEAR_WEAKREFR (s
);
2255 /* Return a pointer to the X_add_number component of a symbol. */
2258 symbol_X_add_number (symbolS
*s
)
2260 if (LOCAL_SYMBOL_CHECK (s
))
2261 return (offsetT
*) &((struct local_symbol
*) s
)->lsy_value
;
2263 return &s
->sy_value
.X_add_number
;
2266 /* Set the value of SYM to the current position in the current segment. */
2269 symbol_set_value_now (symbolS
*sym
)
2271 S_SET_SEGMENT (sym
, now_seg
);
2272 S_SET_VALUE (sym
, frag_now_fix ());
2273 symbol_set_frag (sym
, frag_now
);
2276 /* Set the frag of a symbol. */
2279 symbol_set_frag (symbolS
*s
, fragS
*f
)
2281 if (LOCAL_SYMBOL_CHECK (s
))
2283 local_symbol_set_frag ((struct local_symbol
*) s
, f
);
2287 S_CLEAR_WEAKREFR (s
);
2290 /* Return the frag of a symbol. */
2293 symbol_get_frag (symbolS
*s
)
2295 if (LOCAL_SYMBOL_CHECK (s
))
2296 return local_symbol_get_frag ((struct local_symbol
*) s
);
2300 /* Mark a symbol as having been used. */
2303 symbol_mark_used (symbolS
*s
)
2305 if (LOCAL_SYMBOL_CHECK (s
))
2308 if (S_IS_WEAKREFR (s
))
2309 symbol_mark_used (s
->sy_value
.X_add_symbol
);
2312 /* Clear the mark of whether a symbol has been used. */
2315 symbol_clear_used (symbolS
*s
)
2317 if (LOCAL_SYMBOL_CHECK (s
))
2318 s
= local_symbol_convert ((struct local_symbol
*) s
);
2322 /* Return whether a symbol has been used. */
2325 symbol_used_p (symbolS
*s
)
2327 if (LOCAL_SYMBOL_CHECK (s
))
2332 /* Mark a symbol as having been used in a reloc. */
2335 symbol_mark_used_in_reloc (symbolS
*s
)
2337 if (LOCAL_SYMBOL_CHECK (s
))
2338 s
= local_symbol_convert ((struct local_symbol
*) s
);
2339 s
->sy_used_in_reloc
= 1;
2342 /* Clear the mark of whether a symbol has been used in a reloc. */
2345 symbol_clear_used_in_reloc (symbolS
*s
)
2347 if (LOCAL_SYMBOL_CHECK (s
))
2349 s
->sy_used_in_reloc
= 0;
2352 /* Return whether a symbol has been used in a reloc. */
2355 symbol_used_in_reloc_p (symbolS
*s
)
2357 if (LOCAL_SYMBOL_CHECK (s
))
2359 return s
->sy_used_in_reloc
;
2362 /* Mark a symbol as an MRI common symbol. */
2365 symbol_mark_mri_common (symbolS
*s
)
2367 if (LOCAL_SYMBOL_CHECK (s
))
2368 s
= local_symbol_convert ((struct local_symbol
*) s
);
2369 s
->sy_mri_common
= 1;
2372 /* Clear the mark of whether a symbol is an MRI common symbol. */
2375 symbol_clear_mri_common (symbolS
*s
)
2377 if (LOCAL_SYMBOL_CHECK (s
))
2379 s
->sy_mri_common
= 0;
2382 /* Return whether a symbol is an MRI common symbol. */
2385 symbol_mri_common_p (symbolS
*s
)
2387 if (LOCAL_SYMBOL_CHECK (s
))
2389 return s
->sy_mri_common
;
2392 /* Mark a symbol as having been written. */
2395 symbol_mark_written (symbolS
*s
)
2397 if (LOCAL_SYMBOL_CHECK (s
))
2402 /* Clear the mark of whether a symbol has been written. */
2405 symbol_clear_written (symbolS
*s
)
2407 if (LOCAL_SYMBOL_CHECK (s
))
2412 /* Return whether a symbol has been written. */
2415 symbol_written_p (symbolS
*s
)
2417 if (LOCAL_SYMBOL_CHECK (s
))
2422 /* Mark a symbol has having been resolved. */
2425 symbol_mark_resolved (symbolS
*s
)
2427 if (LOCAL_SYMBOL_CHECK (s
))
2429 local_symbol_mark_resolved ((struct local_symbol
*) s
);
2435 /* Return whether a symbol has been resolved. */
2438 symbol_resolved_p (symbolS
*s
)
2440 if (LOCAL_SYMBOL_CHECK (s
))
2441 return local_symbol_resolved_p ((struct local_symbol
*) s
);
2442 return s
->sy_resolved
;
2445 /* Return whether a symbol is a section symbol. */
2448 symbol_section_p (symbolS
*s ATTRIBUTE_UNUSED
)
2450 if (LOCAL_SYMBOL_CHECK (s
))
2452 return (s
->bsym
->flags
& BSF_SECTION_SYM
) != 0;
2455 /* Return whether a symbol is equated to another symbol. */
2458 symbol_equated_p (symbolS
*s
)
2460 if (LOCAL_SYMBOL_CHECK (s
))
2462 return s
->sy_value
.X_op
== O_symbol
;
2465 /* Return whether a symbol is equated to another symbol, and should be
2466 treated specially when writing out relocs. */
2469 symbol_equated_reloc_p (symbolS
*s
)
2471 if (LOCAL_SYMBOL_CHECK (s
))
2473 /* X_op_symbol, normally not used for O_symbol, is set by
2474 resolve_symbol_value to flag expression syms that have been
2476 return (s
->sy_value
.X_op
== O_symbol
2477 #if defined (OBJ_COFF) && defined (TE_PE)
2480 && ((s
->sy_resolved
&& s
->sy_value
.X_op_symbol
!= NULL
)
2481 || ! S_IS_DEFINED (s
)
2482 || S_IS_COMMON (s
)));
2485 /* Return whether a symbol has a constant value. */
2488 symbol_constant_p (symbolS
*s
)
2490 if (LOCAL_SYMBOL_CHECK (s
))
2492 return s
->sy_value
.X_op
== O_constant
;
2495 /* Return the BFD symbol for a symbol. */
2498 symbol_get_bfdsym (symbolS
*s
)
2500 if (LOCAL_SYMBOL_CHECK (s
))
2501 s
= local_symbol_convert ((struct local_symbol
*) s
);
2505 /* Set the BFD symbol for a symbol. */
2508 symbol_set_bfdsym (symbolS
*s
, asymbol
*bsym
)
2510 if (LOCAL_SYMBOL_CHECK (s
))
2511 s
= local_symbol_convert ((struct local_symbol
*) s
);
2512 /* Usually, it is harmless to reset a symbol to a BFD section
2513 symbol. For example, obj_elf_change_section sets the BFD symbol
2514 of an old symbol with the newly created section symbol. But when
2515 we have multiple sections with the same name, the newly created
2516 section may have the same name as an old section. We check if the
2517 old symbol has been already marked as a section symbol before
2519 if ((s
->bsym
->flags
& BSF_SECTION_SYM
) == 0)
2521 /* else XXX - What do we do now ? */
2524 #ifdef OBJ_SYMFIELD_TYPE
2526 /* Get a pointer to the object format information for a symbol. */
2529 symbol_get_obj (symbolS
*s
)
2531 if (LOCAL_SYMBOL_CHECK (s
))
2532 s
= local_symbol_convert ((struct local_symbol
*) s
);
2536 /* Set the object format information for a symbol. */
2539 symbol_set_obj (symbolS
*s
, OBJ_SYMFIELD_TYPE
*o
)
2541 if (LOCAL_SYMBOL_CHECK (s
))
2542 s
= local_symbol_convert ((struct local_symbol
*) s
);
2546 #endif /* OBJ_SYMFIELD_TYPE */
2548 #ifdef TC_SYMFIELD_TYPE
2550 /* Get a pointer to the processor information for a symbol. */
2553 symbol_get_tc (symbolS
*s
)
2555 if (LOCAL_SYMBOL_CHECK (s
))
2556 s
= local_symbol_convert ((struct local_symbol
*) s
);
2560 /* Set the processor information for a symbol. */
2563 symbol_set_tc (symbolS
*s
, TC_SYMFIELD_TYPE
*o
)
2565 if (LOCAL_SYMBOL_CHECK (s
))
2566 s
= local_symbol_convert ((struct local_symbol
*) s
);
2570 #endif /* TC_SYMFIELD_TYPE */
2575 symbol_lastP
= NULL
;
2576 symbol_rootP
= NULL
; /* In case we have 0 symbols (!!) */
2577 sy_hash
= hash_new ();
2578 local_hash
= hash_new ();
2580 memset ((char *) (&abs_symbol
), '\0', sizeof (abs_symbol
));
2581 #if defined (EMIT_SECTION_SYMBOLS) || !defined (RELOC_REQUIRES_SYMBOL)
2582 abs_symbol
.bsym
= bfd_abs_section
.symbol
;
2584 abs_symbol
.sy_value
.X_op
= O_constant
;
2585 abs_symbol
.sy_frag
= &zero_address_frag
;
2587 if (LOCAL_LABELS_FB
)
2593 /* Maximum indent level.
2594 Available for modification inside a gdb session. */
2595 static int max_indent_level
= 8;
2598 print_symbol_value_1 (FILE *file
, symbolS
*sym
)
2600 const char *name
= S_GET_NAME (sym
);
2601 if (!name
|| !name
[0])
2603 fprintf (file
, "sym %lx %s", (unsigned long) sym
, name
);
2605 if (LOCAL_SYMBOL_CHECK (sym
))
2607 struct local_symbol
*locsym
= (struct local_symbol
*) sym
;
2608 if (local_symbol_get_frag (locsym
) != &zero_address_frag
2609 && local_symbol_get_frag (locsym
) != NULL
)
2610 fprintf (file
, " frag %lx", (long) local_symbol_get_frag (locsym
));
2611 if (local_symbol_resolved_p (locsym
))
2612 fprintf (file
, " resolved");
2613 fprintf (file
, " local");
2617 if (sym
->sy_frag
!= &zero_address_frag
)
2618 fprintf (file
, " frag %lx", (long) sym
->sy_frag
);
2620 fprintf (file
, " written");
2621 if (sym
->sy_resolved
)
2622 fprintf (file
, " resolved");
2623 else if (sym
->sy_resolving
)
2624 fprintf (file
, " resolving");
2625 if (sym
->sy_used_in_reloc
)
2626 fprintf (file
, " used-in-reloc");
2628 fprintf (file
, " used");
2629 if (S_IS_LOCAL (sym
))
2630 fprintf (file
, " local");
2631 if (S_IS_EXTERNAL (sym
))
2632 fprintf (file
, " extern");
2633 if (S_IS_WEAK (sym
))
2634 fprintf (file
, " weak");
2635 if (S_IS_DEBUG (sym
))
2636 fprintf (file
, " debug");
2637 if (S_IS_DEFINED (sym
))
2638 fprintf (file
, " defined");
2640 if (S_IS_WEAKREFR (sym
))
2641 fprintf (file
, " weakrefr");
2642 if (S_IS_WEAKREFD (sym
))
2643 fprintf (file
, " weakrefd");
2644 fprintf (file
, " %s", segment_name (S_GET_SEGMENT (sym
)));
2645 if (symbol_resolved_p (sym
))
2647 segT s
= S_GET_SEGMENT (sym
);
2649 if (s
!= undefined_section
2650 && s
!= expr_section
)
2651 fprintf (file
, " %lx", (long) S_GET_VALUE (sym
));
2653 else if (indent_level
< max_indent_level
2654 && S_GET_SEGMENT (sym
) != undefined_section
)
2657 fprintf (file
, "\n%*s<", indent_level
* 4, "");
2658 if (LOCAL_SYMBOL_CHECK (sym
))
2659 fprintf (file
, "constant %lx",
2660 (long) ((struct local_symbol
*) sym
)->lsy_value
);
2662 print_expr_1 (file
, &sym
->sy_value
);
2663 fprintf (file
, ">");
2670 print_symbol_value (symbolS
*sym
)
2673 print_symbol_value_1 (stderr
, sym
);
2674 fprintf (stderr
, "\n");
2678 print_binary (FILE *file
, const char *name
, expressionS
*exp
)
2681 fprintf (file
, "%s\n%*s<", name
, indent_level
* 4, "");
2682 print_symbol_value_1 (file
, exp
->X_add_symbol
);
2683 fprintf (file
, ">\n%*s<", indent_level
* 4, "");
2684 print_symbol_value_1 (file
, exp
->X_op_symbol
);
2685 fprintf (file
, ">");
2690 print_expr_1 (FILE *file
, expressionS
*exp
)
2692 fprintf (file
, "expr %lx ", (long) exp
);
2696 fprintf (file
, "illegal");
2699 fprintf (file
, "absent");
2702 fprintf (file
, "constant %lx", (long) exp
->X_add_number
);
2706 fprintf (file
, "symbol\n%*s<", indent_level
* 4, "");
2707 print_symbol_value_1 (file
, exp
->X_add_symbol
);
2708 fprintf (file
, ">");
2710 if (exp
->X_add_number
)
2711 fprintf (file
, "\n%*s%lx", indent_level
* 4, "",
2712 (long) exp
->X_add_number
);
2716 fprintf (file
, "register #%d", (int) exp
->X_add_number
);
2719 fprintf (file
, "big");
2722 fprintf (file
, "uminus -<");
2724 print_symbol_value_1 (file
, exp
->X_add_symbol
);
2725 fprintf (file
, ">");
2726 goto maybe_print_addnum
;
2728 fprintf (file
, "bit_not");
2731 print_binary (file
, "multiply", exp
);
2734 print_binary (file
, "divide", exp
);
2737 print_binary (file
, "modulus", exp
);
2740 print_binary (file
, "lshift", exp
);
2743 print_binary (file
, "rshift", exp
);
2745 case O_bit_inclusive_or
:
2746 print_binary (file
, "bit_ior", exp
);
2748 case O_bit_exclusive_or
:
2749 print_binary (file
, "bit_xor", exp
);
2752 print_binary (file
, "bit_and", exp
);
2755 print_binary (file
, "eq", exp
);
2758 print_binary (file
, "ne", exp
);
2761 print_binary (file
, "lt", exp
);
2764 print_binary (file
, "le", exp
);
2767 print_binary (file
, "ge", exp
);
2770 print_binary (file
, "gt", exp
);
2773 print_binary (file
, "logical_and", exp
);
2776 print_binary (file
, "logical_or", exp
);
2780 fprintf (file
, "add\n%*s<", indent_level
* 4, "");
2781 print_symbol_value_1 (file
, exp
->X_add_symbol
);
2782 fprintf (file
, ">\n%*s<", indent_level
* 4, "");
2783 print_symbol_value_1 (file
, exp
->X_op_symbol
);
2784 fprintf (file
, ">");
2785 goto maybe_print_addnum
;
2788 fprintf (file
, "subtract\n%*s<", indent_level
* 4, "");
2789 print_symbol_value_1 (file
, exp
->X_add_symbol
);
2790 fprintf (file
, ">\n%*s<", indent_level
* 4, "");
2791 print_symbol_value_1 (file
, exp
->X_op_symbol
);
2792 fprintf (file
, ">");
2793 goto maybe_print_addnum
;
2795 fprintf (file
, "{unknown opcode %d}", (int) exp
->X_op
);
2802 print_expr (expressionS
*exp
)
2804 print_expr_1 (stderr
, exp
);
2805 fprintf (stderr
, "\n");
2809 symbol_print_statistics (FILE *file
)
2811 hash_print_statistics (file
, "symbol table", sy_hash
);
2812 hash_print_statistics (file
, "mini local symbol table", local_hash
);
2813 fprintf (file
, "%lu mini local symbols created, %lu converted\n",
2814 local_symbol_count
, local_symbol_conversion_count
);