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, 2007, 2008, 2009
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 3, 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 = (char *) obstack_finish (¬es);
114 #ifdef tc_canonicalize_symbol_name
115 ret = tc_canonicalize_symbol_name (ret);
118 if (! symbols_case_sensitive)
122 for (s = ret; *s != '\0'; s++)
130 symbol_create (const char *name, /* It is copied, the caller can destroy/modify. */
131 segT segment, /* Segment identifier (SEG_<something>). */
132 valueT valu, /* Symbol value. */
133 fragS *frag /* Associated fragment. */)
135 char *preserved_copy_of_name;
138 preserved_copy_of_name = save_symbol_name (name);
140 symbolP = (symbolS *) obstack_alloc (¬es, sizeof (symbolS));
142 /* symbol must be born in some fixed state. This seems as good as any. */
143 memset (symbolP, 0, sizeof (symbolS));
145 symbolP->bsym = bfd_make_empty_symbol (stdoutput);
146 if (symbolP->bsym == NULL)
147 as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));
148 S_SET_NAME (symbolP, preserved_copy_of_name);
150 S_SET_SEGMENT (symbolP, segment);
151 S_SET_VALUE (symbolP, valu);
152 symbol_clear_list_pointers (symbolP);
154 symbolP->sy_frag = frag;
156 obj_symbol_new_hook (symbolP);
158 #ifdef tc_symbol_new_hook
159 tc_symbol_new_hook (symbolP);
166 /* Local symbol support. If we can get away with it, we keep only a
167 small amount of information for local symbols. */
169 static symbolS *local_symbol_convert (struct local_symbol *);
171 /* Used for statistics. */
173 static unsigned long local_symbol_count;
174 static unsigned long local_symbol_conversion_count;
176 /* This macro is called with a symbol argument passed by reference.
177 It returns whether this is a local symbol. If necessary, it
178 changes its argument to the real symbol. */
180 #define LOCAL_SYMBOL_CHECK(s) \
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 val, fragS *frag)
194 struct local_symbol *ret;
196 ++local_symbol_count;
198 name_copy = save_symbol_name (name);
200 ret = (struct local_symbol *) obstack_alloc (¬es, sizeof *ret);
201 ret->lsy_marker = NULL;
202 ret->lsy_name = name_copy;
203 ret->lsy_section = section;
204 local_symbol_set_frag (ret, frag);
205 ret->lsy_value = val;
207 hash_jam (local_hash, name_copy, (void *) 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 gas_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);
250 define_sym_at_dot (symbolS *symbolP)
252 symbolP->sy_frag = frag_now;
254 S_SET_OTHER (symbolP, const_flag);
256 S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
257 S_SET_SEGMENT (symbolP, now_seg);
260 /* We have just seen "<name>:".
261 Creates a struct symbol unless it already exists.
263 Gripes if we are redefining a symbol incompatibly (and ignores it). */
266 colon (/* Just seen "x:" - rattle symbols & frags. */
267 const char *sym_name /* Symbol name, as a cannonical string. */
268 /* We copy this string: OK to alter later. */)
270 register symbolS *symbolP; /* Symbol we are working with. */
272 /* Sun local labels go out of scope whenever a non-local symbol is
274 if (LOCAL_LABELS_DOLLAR
275 && !bfd_is_local_label_name (stdoutput, sym_name))
276 dollar_label_clear ();
278 #ifndef WORKING_DOT_WORD
279 if (new_broken_words)
281 struct broken_word *a;
286 if (now_seg == absolute_section)
288 as_bad (_("cannot define symbol `%s' in absolute section"), sym_name);
292 possible_bytes = (md_short_jump_size
293 + new_broken_words * md_long_jump_size);
296 frag_opcode = frag_var (rs_broken_word,
300 (symbolS *) broken_words,
304 /* We want to store the pointer to where to insert the jump
305 table in the fr_opcode of the rs_broken_word frag. This
306 requires a little hackery. */
308 && (frag_tmp->fr_type != rs_broken_word
309 || frag_tmp->fr_opcode))
310 frag_tmp = frag_tmp->fr_next;
312 frag_tmp->fr_opcode = frag_opcode;
313 new_broken_words = 0;
315 for (a = broken_words; a && a->dispfrag == 0; a = a->next_broken_word)
316 a->dispfrag = frag_tmp;
318 #endif /* WORKING_DOT_WORD */
320 if ((symbolP = symbol_find (sym_name)) != 0)
322 S_CLEAR_WEAKREFR (symbolP);
323 #ifdef RESOLVE_SYMBOL_REDEFINITION
324 if (RESOLVE_SYMBOL_REDEFINITION (symbolP))
327 /* Now check for undefined symbols. */
328 if (LOCAL_SYMBOL_CHECK (symbolP))
330 struct local_symbol *locsym = (struct local_symbol *) symbolP;
332 if (locsym->lsy_section != undefined_section
333 && (local_symbol_get_frag (locsym) != frag_now
334 || locsym->lsy_section != now_seg
335 || locsym->lsy_value != frag_now_fix ()))
337 as_bad (_("symbol `%s' is already defined"), sym_name);
341 locsym->lsy_section = now_seg;
342 local_symbol_set_frag (locsym, frag_now);
343 locsym->lsy_value = frag_now_fix ();
345 else if (!(S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
346 || S_IS_COMMON (symbolP)
347 || S_IS_VOLATILE (symbolP))
349 if (S_IS_VOLATILE (symbolP))
351 symbolP = symbol_clone (symbolP, 1);
352 S_SET_VALUE (symbolP, 0);
353 S_CLEAR_VOLATILE (symbolP);
355 if (S_GET_VALUE (symbolP) == 0)
357 define_sym_at_dot (symbolP);
360 #endif /* if we have one, it better be zero. */
365 /* There are still several cases to check:
367 A .comm/.lcomm symbol being redefined as initialized
370 A .comm/.lcomm symbol being redefined with a larger
373 This only used to be allowed on VMS gas, but Sun cc
374 on the sparc also depends on it. */
376 if (((!S_IS_DEBUG (symbolP)
377 && (!S_IS_DEFINED (symbolP) || S_IS_COMMON (symbolP))
378 && S_IS_EXTERNAL (symbolP))
379 || S_GET_SEGMENT (symbolP) == bss_section)
380 && (now_seg == data_section
381 || now_seg == bss_section
382 || now_seg == S_GET_SEGMENT (symbolP)))
384 /* Select which of the 2 cases this is. */
385 if (now_seg != data_section)
387 /* New .comm for prev .comm symbol.
389 If the new size is larger we just change its
390 value. If the new size is smaller, we ignore
392 if (S_GET_VALUE (symbolP)
393 < ((unsigned) frag_now_fix ()))
395 S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
400 /* It is a .comm/.lcomm being converted to initialized
402 define_sym_at_dot (symbolP);
407 #if (!defined (OBJ_AOUT) && !defined (OBJ_MAYBE_AOUT) \
408 && !defined (OBJ_BOUT) && !defined (OBJ_MAYBE_BOUT))
409 static const char *od_buf = "";
413 if (OUTPUT_FLAVOR == bfd_target_aout_flavour)
414 sprintf (od_buf, "%d.%d.",
415 S_GET_OTHER (symbolP),
416 S_GET_DESC (symbolP));
418 as_bad (_("symbol `%s' is already defined as \"%s\"/%s%ld"),
420 segment_name (S_GET_SEGMENT (symbolP)),
422 (long) S_GET_VALUE (symbolP));
424 } /* if the undefined symbol has no value */
428 /* Don't blow up if the definition is the same. */
429 if (!(frag_now == symbolP->sy_frag
430 && S_GET_VALUE (symbolP) == frag_now_fix ()
431 && S_GET_SEGMENT (symbolP) == now_seg))
433 as_bad (_("symbol `%s' is already defined"), sym_name);
434 symbolP = symbol_clone (symbolP, 0);
435 define_sym_at_dot (symbolP);
440 else if (! flag_keep_locals && bfd_is_local_label_name (stdoutput, sym_name))
442 symbolP = (symbolS *) local_symbol_make (sym_name, now_seg,
443 (valueT) frag_now_fix (),
448 symbolP = symbol_new (sym_name, now_seg, (valueT) frag_now_fix (),
451 S_SET_OTHER (symbolP, const_flag);
454 symbol_table_insert (symbolP);
457 if (mri_common_symbol != NULL)
459 /* This symbol is actually being defined within an MRI common
460 section. This requires special handling. */
461 if (LOCAL_SYMBOL_CHECK (symbolP))
462 symbolP = local_symbol_convert ((struct local_symbol *) symbolP);
463 symbolP->sy_value.X_op = O_symbol;
464 symbolP->sy_value.X_add_symbol = mri_common_symbol;
465 symbolP->sy_value.X_add_number = S_GET_VALUE (mri_common_symbol);
466 symbolP->sy_frag = &zero_address_frag;
467 S_SET_SEGMENT (symbolP, expr_section);
468 symbolP->sy_mri_common = 1;
472 tc_frob_label (symbolP);
474 #ifdef obj_frob_label
475 obj_frob_label (symbolP);
481 /* Die if we can't insert the symbol. */
484 symbol_table_insert (symbolS *symbolP)
486 register const char *error_string;
489 know (S_GET_NAME (symbolP));
491 if (LOCAL_SYMBOL_CHECK (symbolP))
493 error_string = hash_jam (local_hash, S_GET_NAME (symbolP),
495 if (error_string != NULL)
496 as_fatal (_("inserting \"%s\" into symbol table failed: %s"),
497 S_GET_NAME (symbolP), error_string);
501 if ((error_string = hash_jam (sy_hash, S_GET_NAME (symbolP), (void *) symbolP)))
503 as_fatal (_("inserting \"%s\" into symbol table failed: %s"),
504 S_GET_NAME (symbolP), error_string);
508 /* If a symbol name does not exist, create it as undefined, and insert
509 it into the symbol table. Return a pointer to it. */
512 symbol_find_or_make (const char *name)
514 register symbolS *symbolP;
516 symbolP = symbol_find (name);
520 if (! flag_keep_locals && bfd_is_local_label_name (stdoutput, name))
522 symbolP = md_undefined_symbol ((char *) name);
526 symbolP = (symbolS *) local_symbol_make (name, undefined_section,
532 symbolP = symbol_make (name);
534 symbol_table_insert (symbolP);
535 } /* if symbol wasn't found */
541 symbol_make (const char *name)
545 /* Let the machine description default it, e.g. for register names. */
546 symbolP = md_undefined_symbol ((char *) name);
549 symbolP = symbol_new (name, undefined_section, (valueT) 0, &zero_address_frag);
555 symbol_clone (symbolS *orgsymP, int replace)
558 asymbol *bsymorg, *bsymnew;
560 /* Running local_symbol_convert on a clone that's not the one currently
561 in local_hash would incorrectly replace the hash entry. Thus the
562 symbol must be converted here. Note that the rest of the function
563 depends on not encountering an unconverted symbol. */
564 if (LOCAL_SYMBOL_CHECK (orgsymP))
565 orgsymP = local_symbol_convert ((struct local_symbol *) orgsymP);
566 bsymorg = orgsymP->bsym;
568 newsymP = (symbolS *) 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 & ~BSF_SECTION_SYM;
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;
602 /* Symbols that won't be output can't be external. */
603 S_CLEAR_EXTERNAL (orgsymP);
604 orgsymP->sy_previous = orgsymP->sy_next = orgsymP;
605 debug_verify_symchain (symbol_rootP, symbol_lastP);
607 symbol_table_insert (newsymP);
611 /* Symbols that won't be output can't be external. */
612 S_CLEAR_EXTERNAL (newsymP);
613 newsymP->sy_previous = newsymP->sy_next = newsymP;
619 /* Referenced symbols, if they are forward references, need to be cloned
620 (without replacing the original) so that the value of the referenced
621 symbols at the point of use . */
623 #undef symbol_clone_if_forward_ref
625 symbol_clone_if_forward_ref (symbolS *symbolP, int is_forward)
627 if (symbolP && !LOCAL_SYMBOL_CHECK (symbolP))
629 symbolS *add_symbol = symbolP->sy_value.X_add_symbol;
630 symbolS *op_symbol = symbolP->sy_value.X_op_symbol;
632 if (symbolP->sy_forward_ref)
637 /* assign_symbol() clones volatile symbols; pre-existing expressions
638 hold references to the original instance, but want the current
639 value. Just repeat the lookup. */
640 if (add_symbol && S_IS_VOLATILE (add_symbol))
641 add_symbol = symbol_find_exact (S_GET_NAME (add_symbol));
642 if (op_symbol && S_IS_VOLATILE (op_symbol))
643 op_symbol = symbol_find_exact (S_GET_NAME (op_symbol));
646 /* Re-using sy_resolving here, as this routine cannot get called from
647 symbol resolution code. */
648 if ((symbolP->bsym->section == expr_section || symbolP->sy_forward_ref)
649 && !symbolP->sy_resolving)
651 symbolP->sy_resolving = 1;
652 add_symbol = symbol_clone_if_forward_ref (add_symbol, is_forward);
653 op_symbol = symbol_clone_if_forward_ref (op_symbol, is_forward);
654 symbolP->sy_resolving = 0;
657 if (symbolP->sy_forward_ref
658 || add_symbol != symbolP->sy_value.X_add_symbol
659 || op_symbol != symbolP->sy_value.X_op_symbol)
661 symbolP = symbol_clone (symbolP, 0);
662 symbolP->sy_resolving = 0;
665 symbolP->sy_value.X_add_symbol = add_symbol;
666 symbolP->sy_value.X_op_symbol = op_symbol;
673 symbol_temp_new (segT seg, valueT ofs, fragS *frag)
675 return symbol_new (FAKE_LABEL_NAME, seg, ofs, frag);
679 symbol_temp_new_now (void)
681 return symbol_temp_new (now_seg, frag_now_fix (), frag_now);
685 symbol_temp_make (void)
687 return symbol_make (FAKE_LABEL_NAME);
690 /* Implement symbol table lookup.
691 In: A symbol's name as a string: '\0' can't be part of a symbol name.
692 Out: NULL if the name was not in the symbol table, else the address
693 of a struct symbol associated with that name. */
696 symbol_find_exact (const char *name)
698 return symbol_find_exact_noref (name, 0);
702 symbol_find_exact_noref (const char *name, int noref)
704 struct local_symbol *locsym;
707 locsym = (struct local_symbol *) hash_find (local_hash, name);
709 return (symbolS *) locsym;
711 sym = ((symbolS *) hash_find (sy_hash, name));
713 /* Any references to the symbol, except for the reference in
714 .weakref, must clear this flag, such that the symbol does not
715 turn into a weak symbol. Note that we don't have to handle the
716 local_symbol case, since a weakrefd is always promoted out of the
717 local_symbol table when it is turned into a weak symbol. */
719 S_CLEAR_WEAKREFD (sym);
725 symbol_find (const char *name)
727 return symbol_find_noref (name, 0);
731 symbol_find_noref (const char *name, int noref)
733 #ifdef tc_canonicalize_symbol_name
736 size_t len = strlen (name) + 1;
738 copy = (char *) alloca (len);
739 memcpy (copy, name, len);
740 name = tc_canonicalize_symbol_name (copy);
744 if (! symbols_case_sensitive)
751 name = copy = (char *) alloca (strlen (name) + 1);
753 while ((c = *orig++) != '\0')
755 *copy++ = TOUPPER (c);
760 return symbol_find_exact_noref (name, noref);
763 /* Once upon a time, symbols were kept in a singly linked list. At
764 least coff needs to be able to rearrange them from time to time, for
765 which a doubly linked list is much more convenient. Loic did these
766 as macros which seemed dangerous to me so they're now functions.
769 /* Link symbol ADDME after symbol TARGET in the chain. */
772 symbol_append (symbolS *addme, symbolS *target,
773 symbolS **rootPP, symbolS **lastPP)
775 if (LOCAL_SYMBOL_CHECK (addme))
777 if (target != NULL && LOCAL_SYMBOL_CHECK (target))
782 know (*rootPP == NULL);
783 know (*lastPP == NULL);
784 addme->sy_next = NULL;
785 addme->sy_previous = NULL;
789 } /* if the list is empty */
791 if (target->sy_next != NULL)
793 target->sy_next->sy_previous = addme;
797 know (*lastPP == target);
799 } /* if we have a next */
801 addme->sy_next = target->sy_next;
802 target->sy_next = addme;
803 addme->sy_previous = target;
805 debug_verify_symchain (symbol_rootP, symbol_lastP);
808 /* Set the chain pointers of SYMBOL to null. */
811 symbol_clear_list_pointers (symbolS *symbolP)
813 if (LOCAL_SYMBOL_CHECK (symbolP))
815 symbolP->sy_next = NULL;
816 symbolP->sy_previous = NULL;
819 /* Remove SYMBOLP from the list. */
822 symbol_remove (symbolS *symbolP, symbolS **rootPP, symbolS **lastPP)
824 if (LOCAL_SYMBOL_CHECK (symbolP))
827 if (symbolP == *rootPP)
829 *rootPP = symbolP->sy_next;
830 } /* if it was the root */
832 if (symbolP == *lastPP)
834 *lastPP = symbolP->sy_previous;
835 } /* if it was the tail */
837 if (symbolP->sy_next != NULL)
839 symbolP->sy_next->sy_previous = symbolP->sy_previous;
842 if (symbolP->sy_previous != NULL)
844 symbolP->sy_previous->sy_next = symbolP->sy_next;
847 debug_verify_symchain (*rootPP, *lastPP);
850 /* Link symbol ADDME before symbol TARGET in the chain. */
853 symbol_insert (symbolS *addme, symbolS *target,
854 symbolS **rootPP, symbolS **lastPP ATTRIBUTE_UNUSED)
856 if (LOCAL_SYMBOL_CHECK (addme))
858 if (LOCAL_SYMBOL_CHECK (target))
861 if (target->sy_previous != NULL)
863 target->sy_previous->sy_next = addme;
867 know (*rootPP == target);
871 addme->sy_previous = target->sy_previous;
872 target->sy_previous = addme;
873 addme->sy_next = target;
875 debug_verify_symchain (*rootPP, *lastPP);
879 verify_symbol_chain (symbolS *rootP, symbolS *lastP)
881 symbolS *symbolP = rootP;
886 for (; symbol_next (symbolP) != NULL; symbolP = symbol_next (symbolP))
888 gas_assert (symbolP->bsym != NULL);
889 gas_assert (symbolP->sy_next->sy_previous == symbolP);
892 gas_assert (lastP == symbolP);
895 #ifdef OBJ_COMPLEX_RELC
898 use_complex_relocs_for (symbolS * symp)
900 switch (symp->sy_value.X_op)
910 if ( (S_IS_COMMON (symp->sy_value.X_add_symbol)
911 || S_IS_LOCAL (symp->sy_value.X_add_symbol))
913 (S_IS_DEFINED (symp->sy_value.X_add_symbol)
914 && S_GET_SEGMENT (symp->sy_value.X_add_symbol) != expr_section))
923 case O_bit_inclusive_or:
925 case O_bit_exclusive_or:
938 if ( (S_IS_COMMON (symp->sy_value.X_add_symbol)
939 || S_IS_LOCAL (symp->sy_value.X_add_symbol))
941 (S_IS_COMMON (symp->sy_value.X_op_symbol)
942 || S_IS_LOCAL (symp->sy_value.X_op_symbol))
944 && S_IS_DEFINED (symp->sy_value.X_add_symbol)
945 && S_IS_DEFINED (symp->sy_value.X_op_symbol)
946 && S_GET_SEGMENT (symp->sy_value.X_add_symbol) != expr_section
947 && S_GET_SEGMENT (symp->sy_value.X_op_symbol) != expr_section)
959 report_op_error (symbolS *symp, symbolS *left, symbolS *right)
963 segT seg_left = S_GET_SEGMENT (left);
964 segT seg_right = right ? S_GET_SEGMENT (right) : 0;
966 if (expr_symbol_where (symp, &file, &line))
968 if (seg_left == undefined_section)
969 as_bad_where (file, line,
970 _("undefined symbol `%s' in operation"),
972 if (seg_right == undefined_section)
973 as_bad_where (file, line,
974 _("undefined symbol `%s' in operation"),
976 if (seg_left != undefined_section
977 && seg_right != undefined_section)
980 as_bad_where (file, line,
981 _("invalid sections for operation on `%s' and `%s'"),
982 S_GET_NAME (left), S_GET_NAME (right));
984 as_bad_where (file, line,
985 _("invalid section for operation on `%s'"),
992 if (seg_left == undefined_section)
993 as_bad (_("undefined symbol `%s' in operation setting `%s'"),
994 S_GET_NAME (left), S_GET_NAME (symp));
995 if (seg_right == undefined_section)
996 as_bad (_("undefined symbol `%s' in operation setting `%s'"),
997 S_GET_NAME (right), S_GET_NAME (symp));
998 if (seg_left != undefined_section
999 && seg_right != undefined_section)
1002 as_bad (_("invalid sections for operation on `%s' and `%s' setting `%s'"),
1003 S_GET_NAME (left), S_GET_NAME (right), S_GET_NAME (symp));
1005 as_bad (_("invalid section for operation on `%s' setting `%s'"),
1006 S_GET_NAME (left), S_GET_NAME (symp));
1011 /* Resolve the value of a symbol. This is called during the final
1012 pass over the symbol table to resolve any symbols with complex
1016 resolve_symbol_value (symbolS *symp)
1019 valueT final_val = 0;
1022 if (LOCAL_SYMBOL_CHECK (symp))
1024 struct local_symbol *locsym = (struct local_symbol *) symp;
1026 final_val = locsym->lsy_value;
1027 if (local_symbol_resolved_p (locsym))
1030 final_val += local_symbol_get_frag (locsym)->fr_address / OCTETS_PER_BYTE;
1034 locsym->lsy_value = final_val;
1035 local_symbol_mark_resolved (locsym);
1041 if (symp->sy_resolved)
1043 if (symp->sy_value.X_op == O_constant)
1044 return (valueT) symp->sy_value.X_add_number;
1050 final_seg = S_GET_SEGMENT (symp);
1052 if (symp->sy_resolving)
1055 as_bad (_("symbol definition loop encountered at `%s'"),
1060 #ifdef OBJ_COMPLEX_RELC
1061 else if (final_seg == expr_section
1062 && use_complex_relocs_for (symp))
1064 symbolS * relc_symbol = NULL;
1065 char * relc_symbol_name = NULL;
1067 relc_symbol_name = symbol_relc_make_expr (& symp->sy_value);
1069 /* For debugging, print out conversion input & output. */
1071 print_expr (& symp->sy_value);
1072 if (relc_symbol_name)
1073 fprintf (stderr, "-> relc symbol: %s\n", relc_symbol_name);
1076 if (relc_symbol_name != NULL)
1077 relc_symbol = symbol_new (relc_symbol_name, undefined_section,
1078 0, & zero_address_frag);
1080 if (relc_symbol == NULL)
1082 as_bad (_("cannot convert expression symbol %s to complex relocation"),
1088 symbol_table_insert (relc_symbol);
1090 /* S_CLEAR_EXTERNAL (relc_symbol); */
1091 if (symp->bsym->flags & BSF_SRELC)
1092 relc_symbol->bsym->flags |= BSF_SRELC;
1094 relc_symbol->bsym->flags |= BSF_RELC;
1095 /* symp->bsym->flags |= BSF_RELC; */
1096 copy_symbol_attributes (symp, relc_symbol);
1097 symp->sy_value.X_op = O_symbol;
1098 symp->sy_value.X_add_symbol = relc_symbol;
1099 symp->sy_value.X_add_number = 0;
1103 final_seg = undefined_section;
1104 goto exit_dont_set_value;
1109 symbolS *add_symbol, *op_symbol;
1110 offsetT left, right;
1111 segT seg_left, seg_right;
1115 symp->sy_resolving = 1;
1117 /* Help out with CSE. */
1118 add_symbol = symp->sy_value.X_add_symbol;
1119 op_symbol = symp->sy_value.X_op_symbol;
1120 final_val = symp->sy_value.X_add_number;
1121 op = symp->sy_value.X_op;
1134 final_val += symp->sy_frag->fr_address / OCTETS_PER_BYTE;
1135 if (final_seg == expr_section)
1136 final_seg = absolute_section;
1145 left = resolve_symbol_value (add_symbol);
1146 seg_left = S_GET_SEGMENT (add_symbol);
1148 symp->sy_value.X_op_symbol = NULL;
1151 if (S_IS_WEAKREFR (symp))
1153 gas_assert (final_val == 0);
1154 if (S_IS_WEAKREFR (add_symbol))
1156 gas_assert (add_symbol->sy_value.X_op == O_symbol
1157 && add_symbol->sy_value.X_add_number == 0);
1158 add_symbol = add_symbol->sy_value.X_add_symbol;
1159 gas_assert (! S_IS_WEAKREFR (add_symbol));
1160 symp->sy_value.X_add_symbol = add_symbol;
1164 if (symp->sy_mri_common)
1166 /* This is a symbol inside an MRI common section. The
1167 relocation routines are going to handle it specially.
1168 Don't change the value. */
1169 resolved = symbol_resolved_p (add_symbol);
1173 if (finalize_syms && final_val == 0)
1175 if (LOCAL_SYMBOL_CHECK (add_symbol))
1176 add_symbol = local_symbol_convert ((struct local_symbol *)
1178 copy_symbol_attributes (symp, add_symbol);
1181 /* If we have equated this symbol to an undefined or common
1182 symbol, keep X_op set to O_symbol, and don't change
1183 X_add_number. This permits the routine which writes out
1184 relocation to detect this case, and convert the
1185 relocation to be against the symbol to which this symbol
1187 if (! S_IS_DEFINED (add_symbol)
1188 #if defined (OBJ_COFF) && defined (TE_PE)
1189 || S_IS_WEAK (add_symbol)
1191 || S_IS_COMMON (add_symbol))
1195 symp->sy_value.X_op = O_symbol;
1196 symp->sy_value.X_add_symbol = add_symbol;
1197 symp->sy_value.X_add_number = final_val;
1198 /* Use X_op_symbol as a flag. */
1199 symp->sy_value.X_op_symbol = add_symbol;
1200 final_seg = seg_left;
1203 resolved = symbol_resolved_p (add_symbol);
1204 symp->sy_resolving = 0;
1205 goto exit_dont_set_value;
1207 else if (finalize_syms
1208 && ((final_seg == expr_section && seg_left != expr_section)
1209 || symbol_shadow_p (symp)))
1211 /* If the symbol is an expression symbol, do similarly
1212 as for undefined and common syms above. Handles
1213 "sym +/- expr" where "expr" cannot be evaluated
1214 immediately, and we want relocations to be against
1215 "sym", eg. because it is weak. */
1216 symp->sy_value.X_op = O_symbol;
1217 symp->sy_value.X_add_symbol = add_symbol;
1218 symp->sy_value.X_add_number = final_val;
1219 symp->sy_value.X_op_symbol = add_symbol;
1220 final_seg = seg_left;
1221 final_val += symp->sy_frag->fr_address + left;
1222 resolved = symbol_resolved_p (add_symbol);
1223 symp->sy_resolving = 0;
1224 goto exit_dont_set_value;
1228 final_val += symp->sy_frag->fr_address + left;
1229 if (final_seg == expr_section || final_seg == undefined_section)
1230 final_seg = seg_left;
1233 resolved = symbol_resolved_p (add_symbol);
1234 if (S_IS_WEAKREFR (symp))
1235 goto exit_dont_set_value;
1241 left = resolve_symbol_value (add_symbol);
1242 seg_left = S_GET_SEGMENT (add_symbol);
1244 /* By reducing these to the relevant dyadic operator, we get
1245 !S -> S == 0 permitted on anything,
1246 -S -> 0 - S only permitted on absolute
1247 ~S -> S ^ ~0 only permitted on absolute */
1248 if (op != O_logical_not && seg_left != absolute_section
1250 report_op_error (symp, add_symbol, NULL);
1252 if (final_seg == expr_section || final_seg == undefined_section)
1253 final_seg = absolute_section;
1257 else if (op == O_logical_not)
1262 final_val += left + symp->sy_frag->fr_address;
1264 resolved = symbol_resolved_p (add_symbol);
1272 case O_bit_inclusive_or:
1274 case O_bit_exclusive_or:
1286 left = resolve_symbol_value (add_symbol);
1287 right = resolve_symbol_value (op_symbol);
1288 seg_left = S_GET_SEGMENT (add_symbol);
1289 seg_right = S_GET_SEGMENT (op_symbol);
1291 /* Simplify addition or subtraction of a constant by folding the
1292 constant into X_add_number. */
1295 if (seg_right == absolute_section)
1300 else if (seg_left == absolute_section)
1303 add_symbol = op_symbol;
1305 seg_left = seg_right;
1309 else if (op == O_subtract)
1311 if (seg_right == absolute_section)
1319 /* Equality and non-equality tests are permitted on anything.
1320 Subtraction, and other comparison operators are permitted if
1321 both operands are in the same section. Otherwise, both
1322 operands must be absolute. We already handled the case of
1323 addition or subtraction of a constant above. This will
1324 probably need to be changed for an object file format which
1325 supports arbitrary expressions, such as IEEE-695. */
1326 if (!(seg_left == absolute_section
1327 && seg_right == absolute_section)
1328 && !(op == O_eq || op == O_ne)
1329 && !((op == O_subtract
1330 || op == O_lt || op == O_le || op == O_ge || op == O_gt)
1331 && seg_left == seg_right
1332 && (seg_left != undefined_section
1333 || add_symbol == op_symbol)))
1335 /* Don't emit messages unless we're finalizing the symbol value,
1336 otherwise we may get the same message multiple times. */
1338 report_op_error (symp, add_symbol, op_symbol);
1339 /* However do not move the symbol into the absolute section
1340 if it cannot currently be resolved - this would confuse
1341 other parts of the assembler into believing that the
1342 expression had been evaluated to zero. */
1348 && (final_seg == expr_section || final_seg == undefined_section))
1349 final_seg = absolute_section;
1351 /* Check for division by zero. */
1352 if ((op == O_divide || op == O_modulus) && right == 0)
1354 /* If seg_right is not absolute_section, then we've
1355 already issued a warning about using a bad symbol. */
1356 if (seg_right == absolute_section && finalize_syms)
1361 if (expr_symbol_where (symp, &file, &line))
1362 as_bad_where (file, line, _("division by zero"));
1364 as_bad (_("division by zero when setting `%s'"),
1371 switch (symp->sy_value.X_op)
1373 case O_multiply: left *= right; break;
1374 case O_divide: left /= right; break;
1375 case O_modulus: left %= right; break;
1376 case O_left_shift: left <<= right; break;
1377 case O_right_shift: left >>= right; break;
1378 case O_bit_inclusive_or: left |= right; break;
1379 case O_bit_or_not: left |= ~right; break;
1380 case O_bit_exclusive_or: left ^= right; break;
1381 case O_bit_and: left &= right; break;
1382 case O_add: left += right; break;
1383 case O_subtract: left -= right; break;
1386 left = (left == right && seg_left == seg_right
1387 && (seg_left != undefined_section
1388 || add_symbol == op_symbol)
1389 ? ~ (offsetT) 0 : 0);
1390 if (symp->sy_value.X_op == O_ne)
1393 case O_lt: left = left < right ? ~ (offsetT) 0 : 0; break;
1394 case O_le: left = left <= right ? ~ (offsetT) 0 : 0; break;
1395 case O_ge: left = left >= right ? ~ (offsetT) 0 : 0; break;
1396 case O_gt: left = left > right ? ~ (offsetT) 0 : 0; break;
1397 case O_logical_and: left = left && right; break;
1398 case O_logical_or: left = left || right; break;
1402 final_val += symp->sy_frag->fr_address + left;
1403 if (final_seg == expr_section || final_seg == undefined_section)
1405 if (seg_left == undefined_section
1406 || seg_right == undefined_section)
1407 final_seg = undefined_section;
1408 else if (seg_left == absolute_section)
1409 final_seg = seg_right;
1411 final_seg = seg_left;
1413 resolved = (symbol_resolved_p (add_symbol)
1414 && symbol_resolved_p (op_symbol));
1419 /* Give an error (below) if not in expr_section. We don't
1420 want to worry about expr_section symbols, because they
1421 are fictional (they are created as part of expression
1422 resolution), and any problems may not actually mean
1427 symp->sy_resolving = 0;
1431 S_SET_VALUE (symp, final_val);
1433 exit_dont_set_value:
1434 /* Always set the segment, even if not finalizing the value.
1435 The segment is used to determine whether a symbol is defined. */
1436 S_SET_SEGMENT (symp, final_seg);
1438 /* Don't worry if we can't resolve an expr_section symbol. */
1442 symp->sy_resolved = 1;
1443 else if (S_GET_SEGMENT (symp) != expr_section)
1445 as_bad (_("can't resolve value for symbol `%s'"),
1447 symp->sy_resolved = 1;
1454 static void resolve_local_symbol (const char *, void *);
1456 /* A static function passed to hash_traverse. */
1459 resolve_local_symbol (const char *key ATTRIBUTE_UNUSED, void *value)
1462 resolve_symbol_value ((symbolS *) value);
1465 /* Resolve all local symbols. */
1468 resolve_local_symbol_values (void)
1470 hash_traverse (local_hash, resolve_local_symbol);
1473 /* Obtain the current value of a symbol without changing any
1474 sub-expressions used. */
1477 snapshot_symbol (symbolS **symbolPP, valueT *valueP, segT *segP, fragS **fragPP)
1479 symbolS *symbolP = *symbolPP;
1481 if (LOCAL_SYMBOL_CHECK (symbolP))
1483 struct local_symbol *locsym = (struct local_symbol *) symbolP;
1485 *valueP = locsym->lsy_value;
1486 *segP = locsym->lsy_section;
1487 *fragPP = local_symbol_get_frag (locsym);
1491 expressionS exp = symbolP->sy_value;
1493 if (!symbolP->sy_resolved && exp.X_op != O_illegal)
1497 if (symbolP->sy_resolving)
1499 symbolP->sy_resolving = 1;
1500 resolved = resolve_expression (&exp);
1501 symbolP->sy_resolving = 0;
1509 if (!symbol_equated_p (symbolP))
1514 symbolP = exp.X_add_symbol;
1521 *symbolPP = symbolP;
1522 *valueP = exp.X_add_number;
1523 *segP = symbolP->bsym->section;
1524 *fragPP = symbolP->sy_frag;
1526 if (*segP == expr_section)
1529 case O_constant: *segP = absolute_section; break;
1530 case O_register: *segP = reg_section; break;
1538 /* Dollar labels look like a number followed by a dollar sign. Eg, "42$".
1539 They are *really* local. That is, they go out of scope whenever we see a
1540 label that isn't local. Also, like fb labels, there can be multiple
1541 instances of a dollar label. Therefor, we name encode each instance with
1542 the instance number, keep a list of defined symbols separate from the real
1543 symbol table, and we treat these buggers as a sparse array. */
1545 static long *dollar_labels;
1546 static long *dollar_label_instances;
1547 static char *dollar_label_defines;
1548 static unsigned long dollar_label_count;
1549 static unsigned long dollar_label_max;
1552 dollar_label_defined (long label)
1556 know ((dollar_labels != NULL) || (dollar_label_count == 0));
1558 for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
1560 return dollar_label_defines[i - dollar_labels];
1562 /* If we get here, label isn't defined. */
1567 dollar_label_instance (long label)
1571 know ((dollar_labels != NULL) || (dollar_label_count == 0));
1573 for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
1575 return (dollar_label_instances[i - dollar_labels]);
1577 /* If we get here, we haven't seen the label before.
1578 Therefore its instance count is zero. */
1583 dollar_label_clear (void)
1585 memset (dollar_label_defines, '\0', (unsigned int) dollar_label_count);
1588 #define DOLLAR_LABEL_BUMP_BY 10
1591 define_dollar_label (long label)
1595 for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
1598 ++dollar_label_instances[i - dollar_labels];
1599 dollar_label_defines[i - dollar_labels] = 1;
1603 /* If we get to here, we don't have label listed yet. */
1605 if (dollar_labels == NULL)
1607 dollar_labels = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long));
1608 dollar_label_instances = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long));
1609 dollar_label_defines = (char *) xmalloc (DOLLAR_LABEL_BUMP_BY);
1610 dollar_label_max = DOLLAR_LABEL_BUMP_BY;
1611 dollar_label_count = 0;
1613 else if (dollar_label_count == dollar_label_max)
1615 dollar_label_max += DOLLAR_LABEL_BUMP_BY;
1616 dollar_labels = (long *) xrealloc ((char *) dollar_labels,
1617 dollar_label_max * sizeof (long));
1618 dollar_label_instances = (long *) xrealloc ((char *) dollar_label_instances,
1619 dollar_label_max * sizeof (long));
1620 dollar_label_defines = (char *) xrealloc (dollar_label_defines, dollar_label_max);
1621 } /* if we needed to grow */
1623 dollar_labels[dollar_label_count] = label;
1624 dollar_label_instances[dollar_label_count] = 1;
1625 dollar_label_defines[dollar_label_count] = 1;
1626 ++dollar_label_count;
1629 /* Caller must copy returned name: we re-use the area for the next name.
1631 The mth occurence of label n: is turned into the symbol "Ln^Am"
1632 where n is the label number and m is the instance number. "L" makes
1633 it a label discarded unless debugging and "^A"('\1') ensures no
1634 ordinary symbol SHOULD get the same name as a local label
1635 symbol. The first "4:" is "L4^A1" - the m numbers begin at 1.
1637 fb labels get the same treatment, except that ^B is used in place
1640 char * /* Return local label name. */
1641 dollar_label_name (register long n, /* we just saw "n$:" : n a number. */
1642 register int augend /* 0 for current instance, 1 for new instance. */)
1645 /* Returned to caller, then copied. Used for created names ("4f"). */
1646 static char symbol_name_build[24];
1649 char symbol_name_temporary[20]; /* Build up a number, BACKWARDS. */
1652 know (augend == 0 || augend == 1);
1653 p = symbol_name_build;
1654 #ifdef LOCAL_LABEL_PREFIX
1655 *p++ = LOCAL_LABEL_PREFIX;
1659 /* Next code just does sprintf( {}, "%d", n); */
1661 q = symbol_name_temporary;
1662 for (*q++ = 0, i = n; i; ++q)
1667 while ((*p = *--q) != '\0')
1670 *p++ = DOLLAR_LABEL_CHAR; /* ^A */
1672 /* Instance number. */
1673 q = symbol_name_temporary;
1674 for (*q++ = 0, i = dollar_label_instance (n) + augend; i; ++q)
1679 while ((*p++ = *--q) != '\0');;
1681 /* The label, as a '\0' ended string, starts at symbol_name_build. */
1682 return symbol_name_build;
1685 /* Somebody else's idea of local labels. They are made by "n:" where n
1686 is any decimal digit. Refer to them with
1687 "nb" for previous (backward) n:
1688 or "nf" for next (forward) n:.
1690 We do a little better and let n be any number, not just a single digit, but
1691 since the other guy's assembler only does ten, we treat the first ten
1694 Like someone else's assembler, we have one set of local label counters for
1695 entire assembly, not one set per (sub)segment like in most assemblers. This
1696 implies that one can refer to a label in another segment, and indeed some
1697 crufty compilers have done just that.
1699 Since there could be a LOT of these things, treat them as a sparse
1702 #define FB_LABEL_SPECIAL (10)
1704 static long fb_low_counter[FB_LABEL_SPECIAL];
1705 static long *fb_labels;
1706 static long *fb_label_instances;
1707 static long fb_label_count;
1708 static long fb_label_max;
1710 /* This must be more than FB_LABEL_SPECIAL. */
1711 #define FB_LABEL_BUMP_BY (FB_LABEL_SPECIAL + 6)
1714 fb_label_init (void)
1716 memset ((void *) fb_low_counter, '\0', sizeof (fb_low_counter));
1719 /* Add one to the instance number of this fb label. */
1722 fb_label_instance_inc (long label)
1726 if (label < FB_LABEL_SPECIAL)
1728 ++fb_low_counter[label];
1732 if (fb_labels != NULL)
1734 for (i = fb_labels + FB_LABEL_SPECIAL;
1735 i < fb_labels + fb_label_count; ++i)
1739 ++fb_label_instances[i - fb_labels];
1741 } /* if we find it */
1742 } /* for each existing label */
1745 /* If we get to here, we don't have label listed yet. */
1747 if (fb_labels == NULL)
1749 fb_labels = (long *) xmalloc (FB_LABEL_BUMP_BY * sizeof (long));
1750 fb_label_instances = (long *) xmalloc (FB_LABEL_BUMP_BY * sizeof (long));
1751 fb_label_max = FB_LABEL_BUMP_BY;
1752 fb_label_count = FB_LABEL_SPECIAL;
1755 else if (fb_label_count == fb_label_max)
1757 fb_label_max += FB_LABEL_BUMP_BY;
1758 fb_labels = (long *) xrealloc ((char *) fb_labels,
1759 fb_label_max * sizeof (long));
1760 fb_label_instances = (long *) xrealloc ((char *) fb_label_instances,
1761 fb_label_max * sizeof (long));
1762 } /* if we needed to grow */
1764 fb_labels[fb_label_count] = label;
1765 fb_label_instances[fb_label_count] = 1;
1770 fb_label_instance (long label)
1774 if (label < FB_LABEL_SPECIAL)
1776 return (fb_low_counter[label]);
1779 if (fb_labels != NULL)
1781 for (i = fb_labels + FB_LABEL_SPECIAL;
1782 i < fb_labels + fb_label_count; ++i)
1786 return (fb_label_instances[i - fb_labels]);
1787 } /* if we find it */
1788 } /* for each existing label */
1791 /* We didn't find the label, so this must be a reference to the
1796 /* Caller must copy returned name: we re-use the area for the next name.
1798 The mth occurence of label n: is turned into the symbol "Ln^Bm"
1799 where n is the label number and m is the instance number. "L" makes
1800 it a label discarded unless debugging and "^B"('\2') ensures no
1801 ordinary symbol SHOULD get the same name as a local label
1802 symbol. The first "4:" is "L4^B1" - the m numbers begin at 1.
1804 dollar labels get the same treatment, except that ^A is used in
1807 char * /* Return local label name. */
1808 fb_label_name (long n, /* We just saw "n:", "nf" or "nb" : n a number. */
1809 long augend /* 0 for nb, 1 for n:, nf. */)
1812 /* Returned to caller, then copied. Used for created names ("4f"). */
1813 static char symbol_name_build[24];
1816 char symbol_name_temporary[20]; /* Build up a number, BACKWARDS. */
1820 know ((unsigned long) augend <= 2 /* See mmix_fb_label. */);
1822 know ((unsigned long) augend <= 1);
1824 p = symbol_name_build;
1825 #ifdef LOCAL_LABEL_PREFIX
1826 *p++ = LOCAL_LABEL_PREFIX;
1830 /* Next code just does sprintf( {}, "%d", n); */
1832 q = symbol_name_temporary;
1833 for (*q++ = 0, i = n; i; ++q)
1838 while ((*p = *--q) != '\0')
1841 *p++ = LOCAL_LABEL_CHAR; /* ^B */
1843 /* Instance number. */
1844 q = symbol_name_temporary;
1845 for (*q++ = 0, i = fb_label_instance (n) + augend; i; ++q)
1850 while ((*p++ = *--q) != '\0');;
1852 /* The label, as a '\0' ended string, starts at symbol_name_build. */
1853 return (symbol_name_build);
1856 /* Decode name that may have been generated by foo_label_name() above.
1857 If the name wasn't generated by foo_label_name(), then return it
1858 unaltered. This is used for error messages. */
1861 decode_local_label_name (char *s)
1864 char *symbol_decode;
1866 int instance_number;
1868 const char *message_format;
1871 #ifdef LOCAL_LABEL_PREFIX
1872 if (s[lindex] == LOCAL_LABEL_PREFIX)
1876 if (s[lindex] != 'L')
1879 for (label_number = 0, p = s + lindex + 1; ISDIGIT (*p); ++p)
1880 label_number = (10 * label_number) + *p - '0';
1882 if (*p == DOLLAR_LABEL_CHAR)
1884 else if (*p == LOCAL_LABEL_CHAR)
1889 for (instance_number = 0, p++; ISDIGIT (*p); ++p)
1890 instance_number = (10 * instance_number) + *p - '0';
1892 message_format = _("\"%d\" (instance number %d of a %s label)");
1893 symbol_decode = (char *) obstack_alloc (¬es, strlen (message_format) + 30);
1894 sprintf (symbol_decode, message_format, label_number, instance_number, type);
1896 return symbol_decode;
1899 /* Get the value of a symbol. */
1902 S_GET_VALUE (symbolS *s)
1904 if (LOCAL_SYMBOL_CHECK (s))
1905 return resolve_symbol_value (s);
1907 if (!s->sy_resolved)
1909 valueT val = resolve_symbol_value (s);
1913 if (S_IS_WEAKREFR (s))
1914 return S_GET_VALUE (s->sy_value.X_add_symbol);
1916 if (s->sy_value.X_op != O_constant)
1918 if (! s->sy_resolved
1919 || s->sy_value.X_op != O_symbol
1920 || (S_IS_DEFINED (s) && ! S_IS_COMMON (s)))
1921 as_bad (_("attempt to get value of unresolved symbol `%s'"),
1924 return (valueT) s->sy_value.X_add_number;
1927 /* Set the value of a symbol. */
1930 S_SET_VALUE (symbolS *s, valueT val)
1932 if (LOCAL_SYMBOL_CHECK (s))
1934 ((struct local_symbol *) s)->lsy_value = val;
1938 s->sy_value.X_op = O_constant;
1939 s->sy_value.X_add_number = (offsetT) val;
1940 s->sy_value.X_unsigned = 0;
1941 S_CLEAR_WEAKREFR (s);
1945 copy_symbol_attributes (symbolS *dest, symbolS *src)
1947 if (LOCAL_SYMBOL_CHECK (dest))
1948 dest = local_symbol_convert ((struct local_symbol *) dest);
1949 if (LOCAL_SYMBOL_CHECK (src))
1950 src = local_symbol_convert ((struct local_symbol *) src);
1952 /* In an expression, transfer the settings of these flags.
1953 The user can override later, of course. */
1954 #define COPIED_SYMFLAGS (BSF_FUNCTION | BSF_OBJECT \
1955 | BSF_GNU_INDIRECT_FUNCTION)
1956 dest->bsym->flags |= src->bsym->flags & COPIED_SYMFLAGS;
1958 #ifdef OBJ_COPY_SYMBOL_ATTRIBUTES
1959 OBJ_COPY_SYMBOL_ATTRIBUTES (dest, src);
1962 #ifdef TC_COPY_SYMBOL_ATTRIBUTES
1963 TC_COPY_SYMBOL_ATTRIBUTES (dest, src);
1968 S_IS_FUNCTION (symbolS *s)
1972 if (LOCAL_SYMBOL_CHECK (s))
1975 flags = s->bsym->flags;
1977 return (flags & BSF_FUNCTION) != 0;
1981 S_IS_EXTERNAL (symbolS *s)
1985 if (LOCAL_SYMBOL_CHECK (s))
1988 flags = s->bsym->flags;
1991 if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL))
1994 return (flags & BSF_GLOBAL) != 0;
1998 S_IS_WEAK (symbolS *s)
2000 if (LOCAL_SYMBOL_CHECK (s))
2002 /* Conceptually, a weakrefr is weak if the referenced symbol is. We
2003 could probably handle a WEAKREFR as always weak though. E.g., if
2004 the referenced symbol has lost its weak status, there's no reason
2005 to keep handling the weakrefr as if it was weak. */
2006 if (S_IS_WEAKREFR (s))
2007 return S_IS_WEAK (s->sy_value.X_add_symbol);
2008 return (s->bsym->flags & BSF_WEAK) != 0;
2012 S_IS_WEAKREFR (symbolS *s)
2014 if (LOCAL_SYMBOL_CHECK (s))
2016 return s->sy_weakrefr != 0;
2020 S_IS_WEAKREFD (symbolS *s)
2022 if (LOCAL_SYMBOL_CHECK (s))
2024 return s->sy_weakrefd != 0;
2028 S_IS_COMMON (symbolS *s)
2030 if (LOCAL_SYMBOL_CHECK (s))
2032 return bfd_is_com_section (s->bsym->section);
2036 S_IS_DEFINED (symbolS *s)
2038 if (LOCAL_SYMBOL_CHECK (s))
2039 return ((struct local_symbol *) s)->lsy_section != undefined_section;
2040 return s->bsym->section != undefined_section;
2044 #ifndef EXTERN_FORCE_RELOC
2045 #define EXTERN_FORCE_RELOC IS_ELF
2048 /* Return true for symbols that should not be reduced to section
2049 symbols or eliminated from expressions, because they may be
2050 overridden by the linker. */
2052 S_FORCE_RELOC (symbolS *s, int strict)
2054 if (LOCAL_SYMBOL_CHECK (s))
2055 return ((struct local_symbol *) s)->lsy_section == undefined_section;
2058 && ((s->bsym->flags & BSF_WEAK) != 0
2059 || (s->bsym->flags & BSF_GNU_INDIRECT_FUNCTION) != 0
2060 || (EXTERN_FORCE_RELOC
2061 && (s->bsym->flags & BSF_GLOBAL) != 0)))
2062 || s->bsym->section == undefined_section
2063 || bfd_is_com_section (s->bsym->section));
2067 S_IS_DEBUG (symbolS *s)
2069 if (LOCAL_SYMBOL_CHECK (s))
2071 if (s->bsym->flags & BSF_DEBUGGING)
2077 S_IS_LOCAL (symbolS *s)
2082 if (LOCAL_SYMBOL_CHECK (s))
2085 flags = s->bsym->flags;
2088 if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL))
2091 if (bfd_get_section (s->bsym) == reg_section)
2094 if (flag_strip_local_absolute
2095 /* Keep BSF_FILE symbols in order to allow debuggers to identify
2096 the source file even when the object file is stripped. */
2097 && (flags & (BSF_GLOBAL | BSF_FILE)) == 0
2098 && bfd_get_section (s->bsym) == absolute_section)
2101 name = S_GET_NAME (s);
2102 return (name != NULL
2104 && (strchr (name, DOLLAR_LABEL_CHAR)
2105 || strchr (name, LOCAL_LABEL_CHAR)
2106 || (! flag_keep_locals
2107 && (bfd_is_local_label (stdoutput, s->bsym)
2110 && name[1] == '?')))));
2114 S_IS_STABD (symbolS *s)
2116 return S_GET_NAME (s) == 0;
2120 S_IS_VOLATILE (const symbolS *s)
2122 if (LOCAL_SYMBOL_CHECK (s))
2124 return s->sy_volatile;
2128 S_IS_FORWARD_REF (const symbolS *s)
2130 if (LOCAL_SYMBOL_CHECK (s))
2132 return s->sy_forward_ref;
2136 S_GET_NAME (symbolS *s)
2138 if (LOCAL_SYMBOL_CHECK (s))
2139 return ((struct local_symbol *) s)->lsy_name;
2140 return s->bsym->name;
2144 S_GET_SEGMENT (symbolS *s)
2146 if (LOCAL_SYMBOL_CHECK (s))
2147 return ((struct local_symbol *) s)->lsy_section;
2148 return s->bsym->section;
2152 S_SET_SEGMENT (symbolS *s, segT seg)
2154 /* Don't reassign section symbols. The direct reason is to prevent seg
2155 faults assigning back to const global symbols such as *ABS*, but it
2156 shouldn't happen anyway. */
2158 if (LOCAL_SYMBOL_CHECK (s))
2160 if (seg == reg_section)
2161 s = local_symbol_convert ((struct local_symbol *) s);
2164 ((struct local_symbol *) s)->lsy_section = seg;
2169 if (s->bsym->flags & BSF_SECTION_SYM)
2171 if (s->bsym->section != seg)
2175 s->bsym->section = seg;
2179 S_SET_EXTERNAL (symbolS *s)
2181 if (LOCAL_SYMBOL_CHECK (s))
2182 s = local_symbol_convert ((struct local_symbol *) s);
2183 if ((s->bsym->flags & BSF_WEAK) != 0)
2185 /* Let .weak override .global. */
2188 if (s->bsym->flags & BSF_SECTION_SYM)
2193 /* Do not reassign section symbols. */
2194 as_where (& file, & line);
2195 as_warn_where (file, line,
2196 _("section symbols are already global"));
2199 #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
2200 if (S_GET_SEGMENT (s) == reg_section)
2202 as_bad ("can't make register symbol `%s' global",
2207 s->bsym->flags |= BSF_GLOBAL;
2208 s->bsym->flags &= ~(BSF_LOCAL | BSF_WEAK);
2211 if (! an_external_name && S_GET_NAME(s)[0] != '.')
2212 an_external_name = S_GET_NAME (s);
2217 S_CLEAR_EXTERNAL (symbolS *s)
2219 if (LOCAL_SYMBOL_CHECK (s))
2221 if ((s->bsym->flags & BSF_WEAK) != 0)
2223 /* Let .weak override. */
2226 s->bsym->flags |= BSF_LOCAL;
2227 s->bsym->flags &= ~(BSF_GLOBAL | BSF_WEAK);
2231 S_SET_WEAK (symbolS *s)
2233 if (LOCAL_SYMBOL_CHECK (s))
2234 s = local_symbol_convert ((struct local_symbol *) s);
2235 #ifdef obj_set_weak_hook
2236 obj_set_weak_hook (s);
2238 s->bsym->flags |= BSF_WEAK;
2239 s->bsym->flags &= ~(BSF_GLOBAL | BSF_LOCAL);
2243 S_SET_WEAKREFR (symbolS *s)
2245 if (LOCAL_SYMBOL_CHECK (s))
2246 s = local_symbol_convert ((struct local_symbol *) s);
2248 /* If the alias was already used, make sure we mark the target as
2249 used as well, otherwise it might be dropped from the symbol
2250 table. This may have unintended side effects if the alias is
2251 later redirected to another symbol, such as keeping the unused
2252 previous target in the symbol table. Since it will be weak, it's
2255 symbol_mark_used (s->sy_value.X_add_symbol);
2259 S_CLEAR_WEAKREFR (symbolS *s)
2261 if (LOCAL_SYMBOL_CHECK (s))
2267 S_SET_WEAKREFD (symbolS *s)
2269 if (LOCAL_SYMBOL_CHECK (s))
2270 s = local_symbol_convert ((struct local_symbol *) s);
2276 S_CLEAR_WEAKREFD (symbolS *s)
2278 if (LOCAL_SYMBOL_CHECK (s))
2283 /* If a weakref target symbol is weak, then it was never
2284 referenced directly before, not even in a .global directive,
2285 so decay it to local. If it remains undefined, it will be
2286 later turned into a global, like any other undefined
2288 if (s->bsym->flags & BSF_WEAK)
2290 #ifdef obj_clear_weak_hook
2291 obj_clear_weak_hook (s);
2293 s->bsym->flags &= ~BSF_WEAK;
2294 s->bsym->flags |= BSF_LOCAL;
2300 S_SET_THREAD_LOCAL (symbolS *s)
2302 if (LOCAL_SYMBOL_CHECK (s))
2303 s = local_symbol_convert ((struct local_symbol *) s);
2304 if (bfd_is_com_section (s->bsym->section)
2305 && (s->bsym->flags & BSF_THREAD_LOCAL) != 0)
2307 s->bsym->flags |= BSF_THREAD_LOCAL;
2308 if ((s->bsym->flags & BSF_FUNCTION) != 0)
2309 as_bad (_("Accessing function `%s' as thread-local object"),
2311 else if (! bfd_is_und_section (s->bsym->section)
2312 && (s->bsym->section->flags & SEC_THREAD_LOCAL) == 0)
2313 as_bad (_("Accessing `%s' as thread-local object"),
2318 S_SET_NAME (symbolS *s, const char *name)
2320 if (LOCAL_SYMBOL_CHECK (s))
2322 ((struct local_symbol *) s)->lsy_name = name;
2325 s->bsym->name = name;
2329 S_SET_VOLATILE (symbolS *s)
2331 if (LOCAL_SYMBOL_CHECK (s))
2332 s = local_symbol_convert ((struct local_symbol *) s);
2337 S_CLEAR_VOLATILE (symbolS *s)
2339 if (!LOCAL_SYMBOL_CHECK (s))
2344 S_SET_FORWARD_REF (symbolS *s)
2346 if (LOCAL_SYMBOL_CHECK (s))
2347 s = local_symbol_convert ((struct local_symbol *) s);
2348 s->sy_forward_ref = 1;
2351 /* Return the previous symbol in a chain. */
2354 symbol_previous (symbolS *s)
2356 if (LOCAL_SYMBOL_CHECK (s))
2358 return s->sy_previous;
2361 /* Return the next symbol in a chain. */
2364 symbol_next (symbolS *s)
2366 if (LOCAL_SYMBOL_CHECK (s))
2371 /* Return a pointer to the value of a symbol as an expression. */
2374 symbol_get_value_expression (symbolS *s)
2376 if (LOCAL_SYMBOL_CHECK (s))
2377 s = local_symbol_convert ((struct local_symbol *) s);
2378 return &s->sy_value;
2381 /* Set the value of a symbol to an expression. */
2384 symbol_set_value_expression (symbolS *s, const expressionS *exp)
2386 if (LOCAL_SYMBOL_CHECK (s))
2387 s = local_symbol_convert ((struct local_symbol *) s);
2389 S_CLEAR_WEAKREFR (s);
2392 /* Return whether 2 symbols are the same. */
2395 symbol_same_p (symbolS *s1, symbolS *s2)
2397 if (s1->bsym == NULL
2398 && local_symbol_converted_p ((struct local_symbol *) s1))
2399 s1 = local_symbol_get_real_symbol ((struct local_symbol *) s1);
2400 if (s2->bsym == NULL
2401 && local_symbol_converted_p ((struct local_symbol *) s2))
2402 s2 = local_symbol_get_real_symbol ((struct local_symbol *) s2);
2406 /* Return a pointer to the X_add_number component of a symbol. */
2409 symbol_X_add_number (symbolS *s)
2411 if (LOCAL_SYMBOL_CHECK (s))
2412 return (offsetT *) &((struct local_symbol *) s)->lsy_value;
2414 return &s->sy_value.X_add_number;
2417 /* Set the value of SYM to the current position in the current segment. */
2420 symbol_set_value_now (symbolS *sym)
2422 S_SET_SEGMENT (sym, now_seg);
2423 S_SET_VALUE (sym, frag_now_fix ());
2424 symbol_set_frag (sym, frag_now);
2427 /* Set the frag of a symbol. */
2430 symbol_set_frag (symbolS *s, fragS *f)
2432 if (LOCAL_SYMBOL_CHECK (s))
2434 local_symbol_set_frag ((struct local_symbol *) s, f);
2438 S_CLEAR_WEAKREFR (s);
2441 /* Return the frag of a symbol. */
2444 symbol_get_frag (symbolS *s)
2446 if (LOCAL_SYMBOL_CHECK (s))
2447 return local_symbol_get_frag ((struct local_symbol *) s);
2451 /* Mark a symbol as having been used. */
2454 symbol_mark_used (symbolS *s)
2456 if (LOCAL_SYMBOL_CHECK (s))
2459 if (S_IS_WEAKREFR (s))
2460 symbol_mark_used (s->sy_value.X_add_symbol);
2463 /* Clear the mark of whether a symbol has been used. */
2466 symbol_clear_used (symbolS *s)
2468 if (LOCAL_SYMBOL_CHECK (s))
2469 s = local_symbol_convert ((struct local_symbol *) s);
2473 /* Return whether a symbol has been used. */
2476 symbol_used_p (symbolS *s)
2478 if (LOCAL_SYMBOL_CHECK (s))
2483 /* Mark a symbol as having been used in a reloc. */
2486 symbol_mark_used_in_reloc (symbolS *s)
2488 if (LOCAL_SYMBOL_CHECK (s))
2489 s = local_symbol_convert ((struct local_symbol *) s);
2490 s->sy_used_in_reloc = 1;
2493 /* Clear the mark of whether a symbol has been used in a reloc. */
2496 symbol_clear_used_in_reloc (symbolS *s)
2498 if (LOCAL_SYMBOL_CHECK (s))
2500 s->sy_used_in_reloc = 0;
2503 /* Return whether a symbol has been used in a reloc. */
2506 symbol_used_in_reloc_p (symbolS *s)
2508 if (LOCAL_SYMBOL_CHECK (s))
2510 return s->sy_used_in_reloc;
2513 /* Mark a symbol as an MRI common symbol. */
2516 symbol_mark_mri_common (symbolS *s)
2518 if (LOCAL_SYMBOL_CHECK (s))
2519 s = local_symbol_convert ((struct local_symbol *) s);
2520 s->sy_mri_common = 1;
2523 /* Clear the mark of whether a symbol is an MRI common symbol. */
2526 symbol_clear_mri_common (symbolS *s)
2528 if (LOCAL_SYMBOL_CHECK (s))
2530 s->sy_mri_common = 0;
2533 /* Return whether a symbol is an MRI common symbol. */
2536 symbol_mri_common_p (symbolS *s)
2538 if (LOCAL_SYMBOL_CHECK (s))
2540 return s->sy_mri_common;
2543 /* Mark a symbol as having been written. */
2546 symbol_mark_written (symbolS *s)
2548 if (LOCAL_SYMBOL_CHECK (s))
2553 /* Clear the mark of whether a symbol has been written. */
2556 symbol_clear_written (symbolS *s)
2558 if (LOCAL_SYMBOL_CHECK (s))
2563 /* Return whether a symbol has been written. */
2566 symbol_written_p (symbolS *s)
2568 if (LOCAL_SYMBOL_CHECK (s))
2573 /* Mark a symbol has having been resolved. */
2576 symbol_mark_resolved (symbolS *s)
2578 if (LOCAL_SYMBOL_CHECK (s))
2580 local_symbol_mark_resolved ((struct local_symbol *) s);
2586 /* Return whether a symbol has been resolved. */
2589 symbol_resolved_p (symbolS *s)
2591 if (LOCAL_SYMBOL_CHECK (s))
2592 return local_symbol_resolved_p ((struct local_symbol *) s);
2593 return s->sy_resolved;
2596 /* Return whether a symbol is a section symbol. */
2599 symbol_section_p (symbolS *s ATTRIBUTE_UNUSED)
2601 if (LOCAL_SYMBOL_CHECK (s))
2603 return (s->bsym->flags & BSF_SECTION_SYM) != 0;
2606 /* Return whether a symbol is equated to another symbol. */
2609 symbol_equated_p (symbolS *s)
2611 if (LOCAL_SYMBOL_CHECK (s))
2613 return s->sy_value.X_op == O_symbol;
2616 /* Return whether a symbol is equated to another symbol, and should be
2617 treated specially when writing out relocs. */
2620 symbol_equated_reloc_p (symbolS *s)
2622 if (LOCAL_SYMBOL_CHECK (s))
2624 /* X_op_symbol, normally not used for O_symbol, is set by
2625 resolve_symbol_value to flag expression syms that have been
2627 return (s->sy_value.X_op == O_symbol
2628 #if defined (OBJ_COFF) && defined (TE_PE)
2631 && ((s->sy_resolved && s->sy_value.X_op_symbol != NULL)
2632 || ! S_IS_DEFINED (s)
2633 || S_IS_COMMON (s)));
2636 /* Return whether a symbol has a constant value. */
2639 symbol_constant_p (symbolS *s)
2641 if (LOCAL_SYMBOL_CHECK (s))
2643 return s->sy_value.X_op == O_constant;
2646 /* Return whether a symbol was cloned and thus removed from the global
2650 symbol_shadow_p (symbolS *s)
2652 if (LOCAL_SYMBOL_CHECK (s))
2654 return s->sy_next == s;
2657 /* Return the BFD symbol for a symbol. */
2660 symbol_get_bfdsym (symbolS *s)
2662 if (LOCAL_SYMBOL_CHECK (s))
2663 s = local_symbol_convert ((struct local_symbol *) s);
2667 /* Set the BFD symbol for a symbol. */
2670 symbol_set_bfdsym (symbolS *s, asymbol *bsym)
2672 if (LOCAL_SYMBOL_CHECK (s))
2673 s = local_symbol_convert ((struct local_symbol *) s);
2674 /* Usually, it is harmless to reset a symbol to a BFD section
2675 symbol. For example, obj_elf_change_section sets the BFD symbol
2676 of an old symbol with the newly created section symbol. But when
2677 we have multiple sections with the same name, the newly created
2678 section may have the same name as an old section. We check if the
2679 old symbol has been already marked as a section symbol before
2681 if ((s->bsym->flags & BSF_SECTION_SYM) == 0)
2683 /* else XXX - What do we do now ? */
2686 #ifdef OBJ_SYMFIELD_TYPE
2688 /* Get a pointer to the object format information for a symbol. */
2691 symbol_get_obj (symbolS *s)
2693 if (LOCAL_SYMBOL_CHECK (s))
2694 s = local_symbol_convert ((struct local_symbol *) s);
2698 /* Set the object format information for a symbol. */
2701 symbol_set_obj (symbolS *s, OBJ_SYMFIELD_TYPE *o)
2703 if (LOCAL_SYMBOL_CHECK (s))
2704 s = local_symbol_convert ((struct local_symbol *) s);
2708 #endif /* OBJ_SYMFIELD_TYPE */
2710 #ifdef TC_SYMFIELD_TYPE
2712 /* Get a pointer to the processor information for a symbol. */
2715 symbol_get_tc (symbolS *s)
2717 if (LOCAL_SYMBOL_CHECK (s))
2718 s = local_symbol_convert ((struct local_symbol *) s);
2722 /* Set the processor information for a symbol. */
2725 symbol_set_tc (symbolS *s, TC_SYMFIELD_TYPE *o)
2727 if (LOCAL_SYMBOL_CHECK (s))
2728 s = local_symbol_convert ((struct local_symbol *) s);
2732 #endif /* TC_SYMFIELD_TYPE */
2737 symbol_lastP = NULL;
2738 symbol_rootP = NULL; /* In case we have 0 symbols (!!) */
2739 sy_hash = hash_new ();
2740 local_hash = hash_new ();
2742 memset ((char *) (&abs_symbol), '\0', sizeof (abs_symbol));
2743 #if defined (EMIT_SECTION_SYMBOLS) || !defined (RELOC_REQUIRES_SYMBOL)
2744 abs_symbol.bsym = bfd_abs_section.symbol;
2746 abs_symbol.sy_value.X_op = O_constant;
2747 abs_symbol.sy_frag = &zero_address_frag;
2749 if (LOCAL_LABELS_FB)
2755 /* Maximum indent level.
2756 Available for modification inside a gdb session. */
2757 static int max_indent_level = 8;
2760 print_symbol_value_1 (FILE *file, symbolS *sym)
2762 const char *name = S_GET_NAME (sym);
2763 if (!name || !name[0])
2765 fprintf (file, "sym ");
2766 fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) sym));
2767 fprintf (file, " %s", name);
2769 if (LOCAL_SYMBOL_CHECK (sym))
2771 struct local_symbol *locsym = (struct local_symbol *) sym;
2773 if (local_symbol_get_frag (locsym) != & zero_address_frag
2774 && local_symbol_get_frag (locsym) != NULL)
2776 fprintf (file, " frag ");
2777 fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) local_symbol_get_frag (locsym)));
2779 if (local_symbol_resolved_p (locsym))
2780 fprintf (file, " resolved");
2781 fprintf (file, " local");
2785 if (sym->sy_frag != &zero_address_frag)
2787 fprintf (file, " frag ");
2788 fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) sym->sy_frag));
2791 fprintf (file, " written");
2792 if (sym->sy_resolved)
2793 fprintf (file, " resolved");
2794 else if (sym->sy_resolving)
2795 fprintf (file, " resolving");
2796 if (sym->sy_used_in_reloc)
2797 fprintf (file, " used-in-reloc");
2799 fprintf (file, " used");
2800 if (S_IS_LOCAL (sym))
2801 fprintf (file, " local");
2802 if (S_IS_EXTERNAL (sym))
2803 fprintf (file, " extern");
2804 if (S_IS_WEAK (sym))
2805 fprintf (file, " weak");
2806 if (S_IS_DEBUG (sym))
2807 fprintf (file, " debug");
2808 if (S_IS_DEFINED (sym))
2809 fprintf (file, " defined");
2811 if (S_IS_WEAKREFR (sym))
2812 fprintf (file, " weakrefr");
2813 if (S_IS_WEAKREFD (sym))
2814 fprintf (file, " weakrefd");
2815 fprintf (file, " %s", segment_name (S_GET_SEGMENT (sym)));
2816 if (symbol_resolved_p (sym))
2818 segT s = S_GET_SEGMENT (sym);
2820 if (s != undefined_section
2821 && s != expr_section)
2822 fprintf (file, " %lx", (unsigned long) S_GET_VALUE (sym));
2824 else if (indent_level < max_indent_level
2825 && S_GET_SEGMENT (sym) != undefined_section)
2828 fprintf (file, "\n%*s<", indent_level * 4, "");
2829 if (LOCAL_SYMBOL_CHECK (sym))
2830 fprintf (file, "constant %lx",
2831 (unsigned long) ((struct local_symbol *) sym)->lsy_value);
2833 print_expr_1 (file, &sym->sy_value);
2834 fprintf (file, ">");
2841 print_symbol_value (symbolS *sym)
2844 print_symbol_value_1 (stderr, sym);
2845 fprintf (stderr, "\n");
2849 print_binary (FILE *file, const char *name, expressionS *exp)
2852 fprintf (file, "%s\n%*s<", name, indent_level * 4, "");
2853 print_symbol_value_1 (file, exp->X_add_symbol);
2854 fprintf (file, ">\n%*s<", indent_level * 4, "");
2855 print_symbol_value_1 (file, exp->X_op_symbol);
2856 fprintf (file, ">");
2861 print_expr_1 (FILE *file, expressionS *exp)
2863 fprintf (file, "expr ");
2864 fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) exp));
2865 fprintf (file, " ");
2869 fprintf (file, "illegal");
2872 fprintf (file, "absent");
2875 fprintf (file, "constant %lx", (unsigned long) exp->X_add_number);
2879 fprintf (file, "symbol\n%*s<", indent_level * 4, "");
2880 print_symbol_value_1 (file, exp->X_add_symbol);
2881 fprintf (file, ">");
2883 if (exp->X_add_number)
2884 fprintf (file, "\n%*s%lx", indent_level * 4, "",
2885 (unsigned long) exp->X_add_number);
2889 fprintf (file, "register #%d", (int) exp->X_add_number);
2892 fprintf (file, "big");
2895 fprintf (file, "uminus -<");
2897 print_symbol_value_1 (file, exp->X_add_symbol);
2898 fprintf (file, ">");
2899 goto maybe_print_addnum;
2901 fprintf (file, "bit_not");
2904 print_binary (file, "multiply", exp);
2907 print_binary (file, "divide", exp);
2910 print_binary (file, "modulus", exp);
2913 print_binary (file, "lshift", exp);
2916 print_binary (file, "rshift", exp);
2918 case O_bit_inclusive_or:
2919 print_binary (file, "bit_ior", exp);
2921 case O_bit_exclusive_or:
2922 print_binary (file, "bit_xor", exp);
2925 print_binary (file, "bit_and", exp);
2928 print_binary (file, "eq", exp);
2931 print_binary (file, "ne", exp);
2934 print_binary (file, "lt", exp);
2937 print_binary (file, "le", exp);
2940 print_binary (file, "ge", exp);
2943 print_binary (file, "gt", exp);
2946 print_binary (file, "logical_and", exp);
2949 print_binary (file, "logical_or", exp);
2953 fprintf (file, "add\n%*s<", indent_level * 4, "");
2954 print_symbol_value_1 (file, exp->X_add_symbol);
2955 fprintf (file, ">\n%*s<", indent_level * 4, "");
2956 print_symbol_value_1 (file, exp->X_op_symbol);
2957 fprintf (file, ">");
2958 goto maybe_print_addnum;
2961 fprintf (file, "subtract\n%*s<", indent_level * 4, "");
2962 print_symbol_value_1 (file, exp->X_add_symbol);
2963 fprintf (file, ">\n%*s<", indent_level * 4, "");
2964 print_symbol_value_1 (file, exp->X_op_symbol);
2965 fprintf (file, ">");
2966 goto maybe_print_addnum;
2968 fprintf (file, "{unknown opcode %d}", (int) exp->X_op);
2975 print_expr (expressionS *exp)
2977 print_expr_1 (stderr, exp);
2978 fprintf (stderr, "\n");
2982 symbol_print_statistics (FILE *file)
2984 hash_print_statistics (file, "symbol table", sy_hash);
2985 hash_print_statistics (file, "mini local symbol table", local_hash);
2986 fprintf (file, "%lu mini local symbols created, %lu converted\n",
2987 local_symbol_count, local_symbol_conversion_count);
2990 #ifdef OBJ_COMPLEX_RELC
2992 /* Convert given symbol to a new complex-relocation symbol name. This
2993 may be a recursive function, since it might be called for non-leaf
2994 nodes (plain symbols) in the expression tree. The caller owns the
2995 returning string, so should free it eventually. Errors are
2996 indicated via as_bad and a NULL return value. The given symbol
2997 is marked with sy_used_in_reloc. */
3000 symbol_relc_make_sym (symbolS * sym)
3002 char * terminal = NULL;
3007 gas_assert (sym != NULL);
3009 /* Recurse to symbol_relc_make_expr if this symbol
3010 is defined as an expression or a plain value. */
3011 if ( S_GET_SEGMENT (sym) == expr_section
3012 || S_GET_SEGMENT (sym) == absolute_section)
3013 return symbol_relc_make_expr (& sym->sy_value);
3015 /* This may be a "fake symbol" L0\001, referring to ".".
3016 Write out a special null symbol to refer to this position. */
3017 if (! strcmp (S_GET_NAME (sym), FAKE_LABEL_NAME))
3018 return xstrdup (".");
3020 /* We hope this is a plain leaf symbol. Construct the encoding
3021 as {S,s}II...:CCCCCCC....
3022 where 'S'/'s' means section symbol / plain symbol
3023 III is decimal for the symbol name length
3024 CCC is the symbol name itself. */
3025 symbol_mark_used_in_reloc (sym);
3027 sname = S_GET_NAME (sym);
3028 sname_len = strlen (sname);
3029 typetag = symbol_section_p (sym) ? 'S' : 's';
3031 terminal = xmalloc (1 /* S or s */
3032 + 8 /* sname_len in decimal */
3034 + sname_len /* name itself */
3037 sprintf (terminal, "%c%d:%s", typetag, sname_len, sname);
3041 /* Convert given value to a new complex-relocation symbol name. This
3042 is a non-recursive function, since it is be called for leaf nodes
3043 (plain values) in the expression tree. The caller owns the
3044 returning string, so should free() it eventually. No errors. */
3047 symbol_relc_make_value (offsetT val)
3049 char * terminal = xmalloc (28); /* Enough for long long. */
3052 bfd_sprintf_vma (stdoutput, terminal + 1, val);
3056 /* Convert given expression to a new complex-relocation symbol name.
3057 This is a recursive function, since it traverses the entire given
3058 expression tree. The caller owns the returning string, so should
3059 free() it eventually. Errors are indicated via as_bad() and a NULL
3063 symbol_relc_make_expr (expressionS * exp)
3065 char * opstr = NULL; /* Operator prefix string. */
3066 int arity = 0; /* Arity of this operator. */
3067 char * operands[3]; /* Up to three operands. */
3068 char * concat_string = NULL;
3070 operands[0] = operands[1] = operands[2] = NULL;
3072 gas_assert (exp != NULL);
3074 /* Match known operators -> fill in opstr, arity, operands[] and fall
3075 through to construct subexpression fragments; may instead return
3076 string directly for leaf nodes. */
3078 /* See expr.h for the meaning of all these enums. Many operators
3079 have an unnatural arity (X_add_number implicitly added). The
3080 conversion logic expands them to explicit "+" subexpressions. */
3085 as_bad ("Unknown expression operator (enum %d)", exp->X_op);
3090 return symbol_relc_make_value (exp->X_add_number);
3093 if (exp->X_add_number)
3097 operands[0] = symbol_relc_make_sym (exp->X_add_symbol);
3098 operands[1] = symbol_relc_make_value (exp->X_add_number);
3102 return symbol_relc_make_sym (exp->X_add_symbol);
3104 /* Helper macros for nesting nodes. */
3106 #define HANDLE_XADD_OPT1(str_) \
3107 if (exp->X_add_number) \
3110 opstr = "+:" str_; \
3111 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3112 operands[1] = symbol_relc_make_value (exp->X_add_number); \
3119 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3123 #define HANDLE_XADD_OPT2(str_) \
3124 if (exp->X_add_number) \
3127 opstr = "+:" str_; \
3128 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3129 operands[1] = symbol_relc_make_sym (exp->X_op_symbol); \
3130 operands[2] = symbol_relc_make_value (exp->X_add_number); \
3136 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3137 operands[1] = symbol_relc_make_sym (exp->X_op_symbol); \
3141 /* Nesting nodes. */
3143 case O_uminus: HANDLE_XADD_OPT1 ("0-");
3144 case O_bit_not: HANDLE_XADD_OPT1 ("~");
3145 case O_logical_not: HANDLE_XADD_OPT1 ("!");
3146 case O_multiply: HANDLE_XADD_OPT2 ("*");
3147 case O_divide: HANDLE_XADD_OPT2 ("/");
3148 case O_modulus: HANDLE_XADD_OPT2 ("%");
3149 case O_left_shift: HANDLE_XADD_OPT2 ("<<");
3150 case O_right_shift: HANDLE_XADD_OPT2 (">>");
3151 case O_bit_inclusive_or: HANDLE_XADD_OPT2 ("|");
3152 case O_bit_exclusive_or: HANDLE_XADD_OPT2 ("^");
3153 case O_bit_and: HANDLE_XADD_OPT2 ("&");
3154 case O_add: HANDLE_XADD_OPT2 ("+");
3155 case O_subtract: HANDLE_XADD_OPT2 ("-");
3156 case O_eq: HANDLE_XADD_OPT2 ("==");
3157 case O_ne: HANDLE_XADD_OPT2 ("!=");
3158 case O_lt: HANDLE_XADD_OPT2 ("<");
3159 case O_le: HANDLE_XADD_OPT2 ("<=");
3160 case O_ge: HANDLE_XADD_OPT2 (">=");
3161 case O_gt: HANDLE_XADD_OPT2 (">");
3162 case O_logical_and: HANDLE_XADD_OPT2 ("&&");
3163 case O_logical_or: HANDLE_XADD_OPT2 ("||");
3166 /* Validate & reject early. */
3167 if (arity >= 1 && ((operands[0] == NULL) || (strlen (operands[0]) == 0)))
3169 if (arity >= 2 && ((operands[1] == NULL) || (strlen (operands[1]) == 0)))
3171 if (arity >= 3 && ((operands[2] == NULL) || (strlen (operands[2]) == 0)))
3175 concat_string = NULL;
3178 /* Allocate new string; include inter-operand padding gaps etc. */
3179 concat_string = xmalloc (strlen (opstr)
3181 + (arity >= 1 ? (strlen (operands[0]) + 1 ) : 0)
3182 + (arity >= 2 ? (strlen (operands[1]) + 1 ) : 0)
3183 + (arity >= 3 ? (strlen (operands[2]) + 0 ) : 0)
3185 gas_assert (concat_string != NULL);
3187 /* Format the thing. */
3188 sprintf (concat_string,
3189 (arity == 0 ? "%s" :
3190 arity == 1 ? "%s:%s" :
3191 arity == 2 ? "%s:%s:%s" :
3192 /* arity == 3 */ "%s:%s:%s:%s"),
3193 opstr, operands[0], operands[1], operands[2]);
3196 /* Free operand strings (not opstr). */
3197 if (arity >= 1) xfree (operands[0]);
3198 if (arity >= 2) xfree (operands[1]);
3199 if (arity >= 3) xfree (operands[2]);
3201 return concat_string;