1 /* symbols.c -symbol table-
2 Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
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, 59 Temple Place - Suite 330, Boston, MA
23 /* #define DEBUG_SYMS / * to debug symbol list maintenance. */
29 #include "obstack.h" /* For "symbols.h" */
32 #include "struc-symbol.h"
34 /* This is non-zero if symbols are case sensitive, which is the
36 int symbols_case_sensitive = 1;
38 #ifndef WORKING_DOT_WORD
39 extern int new_broken_words;
42 /* symbol-name => struct symbol pointer */
43 static struct hash_control *sy_hash;
45 /* Table of local symbols. */
46 static struct hash_control *local_hash;
48 /* Below are commented in "symbols.h". */
49 symbolS *symbol_rootP;
50 symbolS *symbol_lastP;
54 #define debug_verify_symchain verify_symbol_chain
56 #define debug_verify_symchain(root, last) ((void) 0)
59 #define DOLLAR_LABEL_CHAR '\001'
60 #define LOCAL_LABEL_CHAR '\002'
64 static void fb_label_init PARAMS ((void));
65 static long dollar_label_instance PARAMS ((long));
66 static long fb_label_instance PARAMS ((long));
68 static void print_binary PARAMS ((FILE *, const char *, expressionS *));
70 /* Return a pointer to a new symbol. Die if we can't make a new
71 symbol. Fill in the symbol's values. Add symbol to end of symbol
74 This function should be called in the general case of creating a
75 symbol. However, if the output file symbol table has already been
76 set, and you are certain that this symbol won't be wanted in the
77 output file, you can call symbol_create. */
80 symbol_new (name, segment, valu, frag)
86 symbolS *symbolP = symbol_create (name, segment, valu, frag);
88 /* Link to end of symbol chain. */
91 extern int symbol_table_frozen;
92 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 (name)
108 unsigned int name_length;
111 name_length = strlen (name) + 1; /* +1 for \0. */
112 obstack_grow (¬es, name, name_length);
113 ret = obstack_finish (¬es);
115 #ifdef STRIP_UNDERSCORE
120 #ifdef tc_canonicalize_symbol_name
121 ret = tc_canonicalize_symbol_name (ret);
124 if (! symbols_case_sensitive)
128 for (s = (unsigned char *) ret; *s != '\0'; s++)
137 symbol_create (name, segment, valu, frag)
138 const char *name; /* It is copied, the caller can destroy/modify. */
139 segT segment; /* Segment identifier (SEG_<something>). */
140 valueT valu; /* Symbol value. */
141 fragS *frag; /* Associated fragment. */
143 char *preserved_copy_of_name;
146 preserved_copy_of_name = save_symbol_name (name);
148 symbolP = (symbolS *) obstack_alloc (¬es, sizeof (symbolS));
150 /* symbol must be born in some fixed state. This seems as good as any. */
151 memset (symbolP, 0, sizeof (symbolS));
154 symbolP->bsym = bfd_make_empty_symbol (stdoutput);
155 if (symbolP->bsym == NULL)
156 as_perror ("%s", "bfd_make_empty_symbol");
157 symbolP->bsym->udata.p = (PTR) symbolP;
159 S_SET_NAME (symbolP, preserved_copy_of_name);
161 S_SET_SEGMENT (symbolP, segment);
162 S_SET_VALUE (symbolP, valu);
163 symbol_clear_list_pointers (symbolP);
165 symbolP->sy_frag = frag;
166 #ifndef BFD_ASSEMBLER
167 symbolP->sy_number = ~0;
168 symbolP->sy_name_offset = (unsigned int) ~0;
171 obj_symbol_new_hook (symbolP);
173 #ifdef tc_symbol_new_hook
174 tc_symbol_new_hook (symbolP);
182 /* Local symbol support. If we can get away with it, we keep only a
183 small amount of information for local symbols. */
185 static struct local_symbol *local_symbol_make PARAMS ((const char *, segT,
187 static symbolS *local_symbol_convert PARAMS ((struct local_symbol *));
189 /* Used for statistics. */
191 static unsigned long local_symbol_count;
192 static unsigned long local_symbol_conversion_count;
194 /* This macro is called with a symbol argument passed by reference.
195 It returns whether this is a local symbol. If necessary, it
196 changes its argument to the real symbol. */
198 #define LOCAL_SYMBOL_CHECK(s) \
200 ? (local_symbol_converted_p ((struct local_symbol *) s) \
201 ? (s = local_symbol_get_real_symbol ((struct local_symbol *) s), \
206 /* Create a local symbol and insert it into the local hash table. */
208 static struct local_symbol *
209 local_symbol_make (name, section, offset, frag)
216 struct local_symbol *ret;
218 ++local_symbol_count;
220 name_copy = save_symbol_name (name);
222 ret = (struct local_symbol *) obstack_alloc (¬es, sizeof *ret);
223 ret->lsy_marker = NULL;
224 ret->lsy_name = name_copy;
225 ret->lsy_section = section;
226 local_symbol_set_frag (ret, frag);
227 ret->lsy_offset = offset;
229 hash_jam (local_hash, name_copy, (PTR) ret);
234 /* Convert a local symbol into a real symbol. Note that we do not
235 reclaim the space used by the local symbol. */
238 local_symbol_convert (locsym)
239 struct local_symbol *locsym;
243 assert (locsym->lsy_marker == NULL);
244 if (local_symbol_converted_p (locsym))
245 return local_symbol_get_real_symbol (locsym);
247 ++local_symbol_conversion_count;
249 ret = symbol_new (locsym->lsy_name, locsym->lsy_section, locsym->lsy_offset,
250 local_symbol_get_frag (locsym));
252 if (local_symbol_resolved_p (locsym))
253 ret->sy_resolved = 1;
255 /* Local symbols are always either defined or used. */
258 symbol_table_insert (ret);
260 local_symbol_mark_converted (locsym);
261 local_symbol_set_real_symbol (locsym, ret);
263 hash_jam (local_hash, locsym->lsy_name, NULL);
268 #else /* ! BFD_ASSEMBLER */
270 #define LOCAL_SYMBOL_CHECK(s) 0
271 #define local_symbol_convert(s) ((symbolS *) s)
273 #endif /* ! BFD_ASSEMBLER */
275 /* We have just seen "<name>:".
276 Creates a struct symbol unless it already exists.
278 Gripes if we are redefining a symbol incompatibly (and ignores it). */
281 colon (sym_name) /* Just seen "x:" - rattle symbols & frags. */
282 const char *sym_name; /* Symbol name, as a cannonical string. */
283 /* We copy this string: OK to alter later. */
285 register symbolS *symbolP; /* Symbol we are working with. */
287 /* Sun local labels go out of scope whenever a non-local symbol is
289 if (LOCAL_LABELS_DOLLAR)
294 local = bfd_is_local_label_name (stdoutput, sym_name);
296 local = LOCAL_LABEL (sym_name);
300 dollar_label_clear ();
303 #ifndef WORKING_DOT_WORD
304 if (new_broken_words)
306 struct broken_word *a;
311 extern const int md_short_jump_size;
312 extern const int md_long_jump_size;
313 possible_bytes = (md_short_jump_size
314 + new_broken_words * md_long_jump_size);
317 frag_opcode = frag_var (rs_broken_word,
321 (symbolS *) broken_words,
325 /* We want to store the pointer to where to insert the jump
326 table in the fr_opcode of the rs_broken_word frag. This
327 requires a little hackery. */
329 && (frag_tmp->fr_type != rs_broken_word
330 || frag_tmp->fr_opcode))
331 frag_tmp = frag_tmp->fr_next;
333 frag_tmp->fr_opcode = frag_opcode;
334 new_broken_words = 0;
336 for (a = broken_words; a && a->dispfrag == 0; a = a->next_broken_word)
337 a->dispfrag = frag_tmp;
339 #endif /* WORKING_DOT_WORD */
341 if ((symbolP = symbol_find (sym_name)) != 0)
343 #ifdef RESOLVE_SYMBOL_REDEFINITION
344 if (RESOLVE_SYMBOL_REDEFINITION (symbolP))
347 /* Now check for undefined symbols. */
348 if (LOCAL_SYMBOL_CHECK (symbolP))
351 struct local_symbol *locsym = (struct local_symbol *) symbolP;
353 if (locsym->lsy_section != undefined_section
354 && (local_symbol_get_frag (locsym) != frag_now
355 || locsym->lsy_section != now_seg
356 || locsym->lsy_offset != frag_now_fix ()))
358 as_bad (_("Symbol %s already defined."), sym_name);
362 locsym->lsy_section = now_seg;
363 local_symbol_set_frag (locsym, frag_now);
364 locsym->lsy_offset = frag_now_fix ();
367 else if (!S_IS_DEFINED (symbolP) || S_IS_COMMON (symbolP))
369 if (S_GET_VALUE (symbolP) == 0)
371 symbolP->sy_frag = frag_now;
373 S_SET_OTHER (symbolP, const_flag);
375 S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
376 S_SET_SEGMENT (symbolP, now_seg);
379 #endif /* if we have one, it better be zero. */
384 /* There are still several cases to check:
386 A .comm/.lcomm symbol being redefined as initialized
389 A .comm/.lcomm symbol being redefined with a larger
392 This only used to be allowed on VMS gas, but Sun cc
393 on the sparc also depends on it. */
395 if (((!S_IS_DEBUG (symbolP)
396 && (!S_IS_DEFINED (symbolP) || S_IS_COMMON (symbolP))
397 && S_IS_EXTERNAL (symbolP))
398 || S_GET_SEGMENT (symbolP) == bss_section)
399 && (now_seg == data_section
400 || now_seg == S_GET_SEGMENT (symbolP)))
402 /* Select which of the 2 cases this is. */
403 if (now_seg != data_section)
405 /* New .comm for prev .comm symbol.
407 If the new size is larger we just change its
408 value. If the new size is smaller, we ignore
410 if (S_GET_VALUE (symbolP)
411 < ((unsigned) frag_now_fix ()))
413 S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
418 /* It is a .comm/.lcomm being converted to initialized
420 symbolP->sy_frag = frag_now;
422 S_SET_OTHER (symbolP, const_flag);
424 S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
425 S_SET_SEGMENT (symbolP, now_seg); /* Keep N_EXT bit. */
430 #if (!defined (OBJ_AOUT) && !defined (OBJ_MAYBE_AOUT) \
431 && !defined (OBJ_BOUT) && !defined (OBJ_MAYBE_BOUT))
432 static const char *od_buf = "";
437 if (OUTPUT_FLAVOR == bfd_target_aout_flavour)
439 sprintf(od_buf, "%d.%d.",
440 S_GET_OTHER (symbolP),
441 S_GET_DESC (symbolP));
443 as_bad (_("Symbol \"%s\" is already defined as \"%s\"/%s%ld."),
445 segment_name (S_GET_SEGMENT (symbolP)),
447 (long) S_GET_VALUE (symbolP));
449 } /* if the undefined symbol has no value */
453 /* Don't blow up if the definition is the same. */
454 if (!(frag_now == symbolP->sy_frag
455 && S_GET_VALUE (symbolP) == frag_now_fix ()
456 && S_GET_SEGMENT (symbolP) == now_seg))
457 as_bad (_("Symbol %s already defined."), sym_name);
462 else if (! flag_keep_locals && bfd_is_local_label_name (stdoutput, sym_name))
464 symbolP = (symbolS *) local_symbol_make (sym_name, now_seg,
465 (valueT) frag_now_fix (),
468 #endif /* BFD_ASSEMBLER */
471 symbolP = symbol_new (sym_name, now_seg, (valueT) frag_now_fix (),
474 S_SET_OTHER (symbolP, const_flag);
477 symbol_table_insert (symbolP);
480 if (mri_common_symbol != NULL)
482 /* This symbol is actually being defined within an MRI common
483 section. This requires special handling. */
484 if (LOCAL_SYMBOL_CHECK (symbolP))
485 symbolP = local_symbol_convert ((struct local_symbol *) symbolP);
486 symbolP->sy_value.X_op = O_symbol;
487 symbolP->sy_value.X_add_symbol = mri_common_symbol;
488 symbolP->sy_value.X_add_number = S_GET_VALUE (mri_common_symbol);
489 symbolP->sy_frag = &zero_address_frag;
490 S_SET_SEGMENT (symbolP, expr_section);
491 symbolP->sy_mri_common = 1;
495 tc_frob_label (symbolP);
497 #ifdef obj_frob_label
498 obj_frob_label (symbolP);
504 /* Die if we can't insert the symbol. */
507 symbol_table_insert (symbolP)
510 register const char *error_string;
513 know (S_GET_NAME (symbolP));
515 if (LOCAL_SYMBOL_CHECK (symbolP))
517 error_string = hash_jam (local_hash, S_GET_NAME (symbolP),
519 if (error_string != NULL)
520 as_fatal (_("Inserting \"%s\" into symbol table failed: %s"),
521 S_GET_NAME (symbolP), error_string);
525 if ((error_string = hash_jam (sy_hash, S_GET_NAME (symbolP), (PTR) symbolP)))
527 as_fatal (_("Inserting \"%s\" into symbol table failed: %s"),
528 S_GET_NAME (symbolP), error_string);
532 /* If a symbol name does not exist, create it as undefined, and insert
533 it into the symbol table. Return a pointer to it. */
536 symbol_find_or_make (name)
539 register symbolS *symbolP;
541 symbolP = symbol_find (name);
546 if (! flag_keep_locals && bfd_is_local_label_name (stdoutput, name))
548 symbolP = md_undefined_symbol ((char *) name);
552 symbolP = (symbolS *) local_symbol_make (name, undefined_section,
559 symbolP = symbol_make (name);
561 symbol_table_insert (symbolP);
562 } /* if symbol wasn't found */
573 /* Let the machine description default it, e.g. for register names. */
574 symbolP = md_undefined_symbol ((char *) name);
577 symbolP = symbol_new (name, undefined_section, (valueT) 0, &zero_address_frag);
582 /* Implement symbol table lookup.
583 In: A symbol's name as a string: '\0' can't be part of a symbol name.
584 Out: NULL if the name was not in the symbol table, else the address
585 of a struct symbol associated with that name. */
591 #ifdef STRIP_UNDERSCORE
592 return (symbol_find_base (name, 1));
593 #else /* STRIP_UNDERSCORE */
594 return (symbol_find_base (name, 0));
595 #endif /* STRIP_UNDERSCORE */
599 symbol_find_base (name, strip_underscore)
601 int strip_underscore;
603 if (strip_underscore && *name == '_')
606 #ifdef tc_canonicalize_symbol_name
609 size_t len = strlen (name) + 1;
611 copy = (char *) alloca (len);
612 memcpy (copy, name, len);
613 name = tc_canonicalize_symbol_name (copy);
617 if (! symbols_case_sensitive)
624 name = copy = (char *) alloca (strlen (name) + 1);
626 while ((c = *orig++) != '\0')
637 struct local_symbol *locsym;
639 locsym = (struct local_symbol *) hash_find (local_hash, name);
641 return (symbolS *) locsym;
645 return ((symbolS *) hash_find (sy_hash, name));
648 /* Once upon a time, symbols were kept in a singly linked list. At
649 least coff needs to be able to rearrange them from time to time, for
650 which a doubly linked list is much more convenient. Loic did these
651 as macros which seemed dangerous to me so they're now functions.
654 /* Link symbol ADDME after symbol TARGET in the chain. */
657 symbol_append (addme, target, rootPP, lastPP)
663 if (LOCAL_SYMBOL_CHECK (addme))
665 if (target != NULL && LOCAL_SYMBOL_CHECK (target))
670 know (*rootPP == NULL);
671 know (*lastPP == NULL);
672 addme->sy_next = NULL;
673 #ifdef SYMBOLS_NEED_BACKPOINTERS
674 addme->sy_previous = NULL;
679 } /* if the list is empty */
681 if (target->sy_next != NULL)
683 #ifdef SYMBOLS_NEED_BACKPOINTERS
684 target->sy_next->sy_previous = addme;
685 #endif /* SYMBOLS_NEED_BACKPOINTERS */
689 know (*lastPP == target);
691 } /* if we have a next */
693 addme->sy_next = target->sy_next;
694 target->sy_next = addme;
696 #ifdef SYMBOLS_NEED_BACKPOINTERS
697 addme->sy_previous = target;
698 #endif /* SYMBOLS_NEED_BACKPOINTERS */
700 debug_verify_symchain (symbol_rootP, symbol_lastP);
703 /* Set the chain pointers of SYMBOL to null. */
706 symbol_clear_list_pointers (symbolP)
709 if (LOCAL_SYMBOL_CHECK (symbolP))
711 symbolP->sy_next = NULL;
712 #ifdef SYMBOLS_NEED_BACKPOINTERS
713 symbolP->sy_previous = NULL;
717 #ifdef SYMBOLS_NEED_BACKPOINTERS
718 /* Remove SYMBOLP from the list. */
721 symbol_remove (symbolP, rootPP, lastPP)
726 if (LOCAL_SYMBOL_CHECK (symbolP))
729 if (symbolP == *rootPP)
731 *rootPP = symbolP->sy_next;
732 } /* if it was the root */
734 if (symbolP == *lastPP)
736 *lastPP = symbolP->sy_previous;
737 } /* if it was the tail */
739 if (symbolP->sy_next != NULL)
741 symbolP->sy_next->sy_previous = symbolP->sy_previous;
744 if (symbolP->sy_previous != NULL)
746 symbolP->sy_previous->sy_next = symbolP->sy_next;
749 debug_verify_symchain (*rootPP, *lastPP);
752 /* Link symbol ADDME before symbol TARGET in the chain. */
755 symbol_insert (addme, target, rootPP, lastPP)
759 symbolS **lastPP ATTRIBUTE_UNUSED;
761 if (LOCAL_SYMBOL_CHECK (addme))
763 if (LOCAL_SYMBOL_CHECK (target))
766 if (target->sy_previous != NULL)
768 target->sy_previous->sy_next = addme;
772 know (*rootPP == target);
776 addme->sy_previous = target->sy_previous;
777 target->sy_previous = addme;
778 addme->sy_next = target;
780 debug_verify_symchain (*rootPP, *lastPP);
783 #endif /* SYMBOLS_NEED_BACKPOINTERS */
786 verify_symbol_chain (rootP, lastP)
790 symbolS *symbolP = rootP;
795 for (; symbol_next (symbolP) != NULL; symbolP = symbol_next (symbolP))
798 assert (symbolP->bsym != NULL);
800 #ifdef SYMBOLS_NEED_BACKPOINTERS
801 assert (symbolP->sy_next->sy_previous == symbolP);
803 /* Walk the list anyways, to make sure pointers are still good. */
805 #endif /* SYMBOLS_NEED_BACKPOINTERS */
808 assert (lastP == symbolP);
812 verify_symbol_chain_2 (sym)
815 symbolS *p = sym, *n = sym;
816 #ifdef SYMBOLS_NEED_BACKPOINTERS
817 while (symbol_previous (p))
818 p = symbol_previous (p);
820 while (symbol_next (n))
822 verify_symbol_chain (p, n);
825 /* Resolve the value of a symbol. This is called during the final
826 pass over the symbol table to resolve any symbols with complex
830 resolve_symbol_value (symp, finalize)
839 if (LOCAL_SYMBOL_CHECK (symp))
841 struct local_symbol *locsym = (struct local_symbol *) symp;
843 if (local_symbol_resolved_p (locsym))
844 return locsym->lsy_offset / bfd_octets_per_byte (stdoutput);
846 final_val = (local_symbol_get_frag (locsym)->fr_address
847 + locsym->lsy_offset) / bfd_octets_per_byte (stdoutput);
851 locsym->lsy_offset = final_val;
852 local_symbol_mark_resolved (locsym);
859 if (symp->sy_resolved)
861 if (symp->sy_value.X_op == O_constant)
862 return (valueT) symp->sy_value.X_add_number;
868 final_seg = S_GET_SEGMENT (symp);
869 /* Expressions aren't really symbols, so don't finalize their values
870 until relaxation is complete. */
871 if (final_seg == expr_section && finalize != 2)
874 if (symp->sy_resolving)
877 as_bad (_("Symbol definition loop encountered at %s"),
884 symbolS *add_symbol, *op_symbol;
886 segT seg_left, seg_right;
889 symp->sy_resolving = 1;
891 /* Help out with CSE. */
892 add_symbol = symp->sy_value.X_add_symbol;
893 op_symbol = symp->sy_value.X_op_symbol;
894 final_val = symp->sy_value.X_add_number;
895 op = symp->sy_value.X_op;
908 final_val += symp->sy_frag->fr_address / OCTETS_PER_BYTE;
909 if (final_seg == expr_section)
910 final_seg = absolute_section;
916 left = resolve_symbol_value (add_symbol, finalize);
919 if (symp->sy_mri_common)
921 /* This is a symbol inside an MRI common section. The
922 relocation routines are going to handle it specially.
923 Don't change the value. */
924 resolved = symbol_resolved_p (add_symbol);
928 if (finalize && final_val == 0)
930 if (LOCAL_SYMBOL_CHECK (add_symbol))
931 add_symbol = local_symbol_convert ((struct local_symbol *)
933 copy_symbol_attributes (symp, add_symbol);
936 /* If we have equated this symbol to an undefined symbol, we
937 keep X_op set to O_symbol, and we don't change
938 X_add_number. This permits the routine which writes out
939 relocation to detect this case, and convert the
940 relocation to be against the symbol to which this symbol
942 if (! S_IS_DEFINED (add_symbol) || S_IS_COMMON (add_symbol))
946 S_SET_SEGMENT (symp, S_GET_SEGMENT (add_symbol));
947 symp->sy_value.X_op = O_symbol;
948 symp->sy_value.X_add_symbol = add_symbol;
949 symp->sy_value.X_add_number = final_val;
952 resolved = symbol_resolved_p (add_symbol);
953 goto exit_dont_set_value;
957 final_val += symp->sy_frag->fr_address + left;
958 if (final_seg == expr_section || final_seg == undefined_section)
959 final_seg = S_GET_SEGMENT (add_symbol);
962 resolved = symbol_resolved_p (add_symbol);
968 left = resolve_symbol_value (add_symbol, finalize);
972 else if (op == O_logical_not)
977 final_val += left + symp->sy_frag->fr_address;
978 if (final_seg == expr_section || final_seg == undefined_section)
979 final_seg = absolute_section;
981 resolved = symbol_resolved_p (add_symbol);
989 case O_bit_inclusive_or:
991 case O_bit_exclusive_or:
1003 left = resolve_symbol_value (add_symbol, finalize);
1004 right = resolve_symbol_value (op_symbol, finalize);
1005 seg_left = S_GET_SEGMENT (add_symbol);
1006 seg_right = S_GET_SEGMENT (op_symbol);
1008 /* Simplify addition or subtraction of a constant by folding the
1009 constant into X_add_number. */
1010 if (op == O_add || op == O_subtract)
1012 if (seg_right == absolute_section)
1022 else if (seg_left == absolute_section && op == O_add)
1026 add_symbol = op_symbol;
1033 /* Subtraction is permitted if both operands are in the same
1034 section. Otherwise, both operands must be absolute. We
1035 already handled the case of addition or subtraction of a
1036 constant above. This will probably need to be changed
1037 for an object file format which supports arbitrary
1038 expressions, such as IEEE-695. */
1039 /* Don't emit messages unless we're finalizing the symbol value,
1040 otherwise we may get the same message multiple times. */
1041 if ((seg_left != absolute_section
1042 || seg_right != absolute_section)
1043 && (op != O_subtract
1044 || seg_left != seg_right
1045 || seg_left == undefined_section)
1051 if (expr_symbol_where (symp, &file, &line))
1053 if (seg_left == undefined_section)
1054 as_bad_where (file, line,
1055 _("undefined symbol %s in operation"),
1056 S_GET_NAME (symp->sy_value.X_add_symbol));
1057 if (seg_right == undefined_section)
1058 as_bad_where (file, line,
1059 _("undefined symbol %s in operation"),
1060 S_GET_NAME (symp->sy_value.X_op_symbol));
1061 if (seg_left != undefined_section
1062 && seg_right != undefined_section)
1063 as_bad_where (file, line,
1064 _("invalid section for operation"));
1068 if (seg_left == undefined_section)
1069 as_bad (_("undefined symbol %s in operation setting %s"),
1070 S_GET_NAME (symp->sy_value.X_add_symbol),
1072 if (seg_right == undefined_section)
1073 as_bad (_("undefined symbol %s in operation setting %s"),
1074 S_GET_NAME (symp->sy_value.X_op_symbol),
1076 if (seg_left != undefined_section
1077 && seg_right != undefined_section)
1078 as_bad (_("invalid section for operation setting %s"),
1083 /* Check for division by zero. */
1084 if ((op == O_divide || op == O_modulus) && right == 0)
1086 /* If seg_right is not absolute_section, then we've
1087 already issued a warning about using a bad symbol. */
1088 if (seg_right == absolute_section && finalize)
1093 if (expr_symbol_where (symp, &file, &line))
1094 as_bad_where (file, line, _("division by zero"));
1096 as_bad (_("division by zero when setting %s"),
1103 switch (symp->sy_value.X_op)
1105 case O_multiply: left *= right; break;
1106 case O_divide: left /= right; break;
1107 case O_modulus: left %= right; break;
1108 case O_left_shift: left <<= right; break;
1109 case O_right_shift: left >>= right; break;
1110 case O_bit_inclusive_or: left |= right; break;
1111 case O_bit_or_not: left |= ~right; break;
1112 case O_bit_exclusive_or: left ^= right; break;
1113 case O_bit_and: left &= right; break;
1114 case O_add: left += right; break;
1115 case O_subtract: left -= right; break;
1116 case O_eq: left = left == right ? ~ (offsetT) 0 : 0; break;
1117 case O_ne: left = left != right ? ~ (offsetT) 0 : 0; break;
1118 case O_lt: left = left < right ? ~ (offsetT) 0 : 0; break;
1119 case O_le: left = left <= right ? ~ (offsetT) 0 : 0; break;
1120 case O_ge: left = left >= right ? ~ (offsetT) 0 : 0; break;
1121 case O_gt: left = left > right ? ~ (offsetT) 0 : 0; break;
1122 case O_logical_and: left = left && right; break;
1123 case O_logical_or: left = left || right; break;
1127 final_val += symp->sy_frag->fr_address + left;
1128 if (final_seg == expr_section || final_seg == undefined_section)
1129 final_seg = absolute_section;
1130 resolved = (symbol_resolved_p (add_symbol)
1131 && symbol_resolved_p (op_symbol));
1137 /* Give an error (below) if not in expr_section. We don't
1138 want to worry about expr_section symbols, because they
1139 are fictional (they are created as part of expression
1140 resolution), and any problems may not actually mean
1145 symp->sy_resolving = 0;
1150 S_SET_VALUE (symp, final_val);
1152 #if defined (OBJ_AOUT) && ! defined (BFD_ASSEMBLER)
1153 /* The old a.out backend does not handle S_SET_SEGMENT correctly
1154 for a stab symbol, so we use this bad hack. */
1155 if (final_seg != S_GET_SEGMENT (symp))
1157 S_SET_SEGMENT (symp, final_seg);
1160 exit_dont_set_value:
1161 /* Don't worry if we can't resolve an expr_section symbol. */
1165 symp->sy_resolved = 1;
1166 else if (S_GET_SEGMENT (symp) != expr_section)
1168 as_bad (_("can't resolve value for symbol \"%s\""),
1170 symp->sy_resolved = 1;
1177 #ifdef BFD_ASSEMBLER
1179 static void resolve_local_symbol PARAMS ((const char *, PTR));
1181 /* A static function passed to hash_traverse. */
1184 resolve_local_symbol (key, value)
1185 const char *key ATTRIBUTE_UNUSED;
1189 resolve_symbol_value (value, finalize_syms);
1194 /* Resolve all local symbols. */
1197 resolve_local_symbol_values ()
1199 #ifdef BFD_ASSEMBLER
1200 hash_traverse (local_hash, resolve_local_symbol);
1204 /* Dollar labels look like a number followed by a dollar sign. Eg, "42$".
1205 They are *really* local. That is, they go out of scope whenever we see a
1206 label that isn't local. Also, like fb labels, there can be multiple
1207 instances of a dollar label. Therefor, we name encode each instance with
1208 the instance number, keep a list of defined symbols separate from the real
1209 symbol table, and we treat these buggers as a sparse array. */
1211 static long *dollar_labels;
1212 static long *dollar_label_instances;
1213 static char *dollar_label_defines;
1214 static unsigned long dollar_label_count;
1215 static unsigned long dollar_label_max;
1218 dollar_label_defined (label)
1223 know ((dollar_labels != NULL) || (dollar_label_count == 0));
1225 for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
1227 return dollar_label_defines[i - dollar_labels];
1229 /* If we get here, label isn't defined. */
1234 dollar_label_instance (label)
1239 know ((dollar_labels != NULL) || (dollar_label_count == 0));
1241 for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
1243 return (dollar_label_instances[i - dollar_labels]);
1245 /* If we get here, we haven't seen the label before.
1246 Therefore its instance count is zero. */
1251 dollar_label_clear ()
1253 memset (dollar_label_defines, '\0', (unsigned int) dollar_label_count);
1256 #define DOLLAR_LABEL_BUMP_BY 10
1259 define_dollar_label (label)
1264 for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
1267 ++dollar_label_instances[i - dollar_labels];
1268 dollar_label_defines[i - dollar_labels] = 1;
1272 /* If we get to here, we don't have label listed yet. */
1274 if (dollar_labels == NULL)
1276 dollar_labels = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long));
1277 dollar_label_instances = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long));
1278 dollar_label_defines = xmalloc (DOLLAR_LABEL_BUMP_BY);
1279 dollar_label_max = DOLLAR_LABEL_BUMP_BY;
1280 dollar_label_count = 0;
1282 else if (dollar_label_count == dollar_label_max)
1284 dollar_label_max += DOLLAR_LABEL_BUMP_BY;
1285 dollar_labels = (long *) xrealloc ((char *) dollar_labels,
1286 dollar_label_max * sizeof (long));
1287 dollar_label_instances = (long *) xrealloc ((char *) dollar_label_instances,
1288 dollar_label_max * sizeof (long));
1289 dollar_label_defines = xrealloc (dollar_label_defines, dollar_label_max);
1290 } /* if we needed to grow */
1292 dollar_labels[dollar_label_count] = label;
1293 dollar_label_instances[dollar_label_count] = 1;
1294 dollar_label_defines[dollar_label_count] = 1;
1295 ++dollar_label_count;
1298 /* Caller must copy returned name: we re-use the area for the next name.
1300 The mth occurence of label n: is turned into the symbol "Ln^Am"
1301 where n is the label number and m is the instance number. "L" makes
1302 it a label discarded unless debugging and "^A"('\1') ensures no
1303 ordinary symbol SHOULD get the same name as a local label
1304 symbol. The first "4:" is "L4^A1" - the m numbers begin at 1.
1306 fb labels get the same treatment, except that ^B is used in place
1309 char * /* Return local label name. */
1310 dollar_label_name (n, augend)
1311 register long n; /* we just saw "n$:" : n a number. */
1312 register int augend; /* 0 for current instance, 1 for new instance. */
1315 /* Returned to caller, then copied. Used for created names ("4f"). */
1316 static char symbol_name_build[24];
1319 char symbol_name_temporary[20]; /* Build up a number, BACKWARDS. */
1322 know (augend == 0 || augend == 1);
1323 p = symbol_name_build;
1324 #ifdef LOCAL_LABEL_PREFIX
1325 *p++ = LOCAL_LABEL_PREFIX;
1329 /* Next code just does sprintf( {}, "%d", n); */
1331 q = symbol_name_temporary;
1332 for (*q++ = 0, i = n; i; ++q)
1337 while ((*p = *--q) != '\0')
1340 *p++ = DOLLAR_LABEL_CHAR; /* ^A */
1342 /* Instance number. */
1343 q = symbol_name_temporary;
1344 for (*q++ = 0, i = dollar_label_instance (n) + augend; i; ++q)
1349 while ((*p++ = *--q) != '\0');;
1351 /* The label, as a '\0' ended string, starts at symbol_name_build. */
1352 return symbol_name_build;
1355 /* Sombody else's idea of local labels. They are made by "n:" where n
1356 is any decimal digit. Refer to them with
1357 "nb" for previous (backward) n:
1358 or "nf" for next (forward) n:.
1360 We do a little better and let n be any number, not just a single digit, but
1361 since the other guy's assembler only does ten, we treat the first ten
1364 Like someone else's assembler, we have one set of local label counters for
1365 entire assembly, not one set per (sub)segment like in most assemblers. This
1366 implies that one can refer to a label in another segment, and indeed some
1367 crufty compilers have done just that.
1369 Since there could be a LOT of these things, treat them as a sparse
1372 #define FB_LABEL_SPECIAL (10)
1374 static long fb_low_counter[FB_LABEL_SPECIAL];
1375 static long *fb_labels;
1376 static long *fb_label_instances;
1377 static long fb_label_count;
1378 static long fb_label_max;
1380 /* This must be more than FB_LABEL_SPECIAL. */
1381 #define FB_LABEL_BUMP_BY (FB_LABEL_SPECIAL + 6)
1386 memset ((void *) fb_low_counter, '\0', sizeof (fb_low_counter));
1389 /* Add one to the instance number of this fb label. */
1392 fb_label_instance_inc (label)
1397 if (label < FB_LABEL_SPECIAL)
1399 ++fb_low_counter[label];
1403 if (fb_labels != NULL)
1405 for (i = fb_labels + FB_LABEL_SPECIAL;
1406 i < fb_labels + fb_label_count; ++i)
1410 ++fb_label_instances[i - fb_labels];
1412 } /* if we find it */
1413 } /* for each existing label */
1416 /* If we get to here, we don't have label listed yet. */
1418 if (fb_labels == NULL)
1420 fb_labels = (long *) xmalloc (FB_LABEL_BUMP_BY * sizeof (long));
1421 fb_label_instances = (long *) xmalloc (FB_LABEL_BUMP_BY * sizeof (long));
1422 fb_label_max = FB_LABEL_BUMP_BY;
1423 fb_label_count = FB_LABEL_SPECIAL;
1426 else if (fb_label_count == fb_label_max)
1428 fb_label_max += FB_LABEL_BUMP_BY;
1429 fb_labels = (long *) xrealloc ((char *) fb_labels,
1430 fb_label_max * sizeof (long));
1431 fb_label_instances = (long *) xrealloc ((char *) fb_label_instances,
1432 fb_label_max * sizeof (long));
1433 } /* if we needed to grow */
1435 fb_labels[fb_label_count] = label;
1436 fb_label_instances[fb_label_count] = 1;
1441 fb_label_instance (label)
1446 if (label < FB_LABEL_SPECIAL)
1448 return (fb_low_counter[label]);
1451 if (fb_labels != NULL)
1453 for (i = fb_labels + FB_LABEL_SPECIAL;
1454 i < fb_labels + fb_label_count; ++i)
1458 return (fb_label_instances[i - fb_labels]);
1459 } /* if we find it */
1460 } /* for each existing label */
1463 /* We didn't find the label, so this must be a reference to the
1468 /* Caller must copy returned name: we re-use the area for the next name.
1470 The mth occurence of label n: is turned into the symbol "Ln^Bm"
1471 where n is the label number and m is the instance number. "L" makes
1472 it a label discarded unless debugging and "^B"('\2') ensures no
1473 ordinary symbol SHOULD get the same name as a local label
1474 symbol. The first "4:" is "L4^B1" - the m numbers begin at 1.
1476 dollar labels get the same treatment, except that ^A is used in
1479 char * /* Return local label name. */
1480 fb_label_name (n, augend)
1481 long n; /* We just saw "n:", "nf" or "nb" : n a number. */
1482 long augend; /* 0 for nb, 1 for n:, nf. */
1485 /* Returned to caller, then copied. Used for created names ("4f"). */
1486 static char symbol_name_build[24];
1489 char symbol_name_temporary[20]; /* Build up a number, BACKWARDS. */
1492 know (augend == 0 || augend == 1);
1493 p = symbol_name_build;
1494 #ifdef LOCAL_LABEL_PREFIX
1495 *p++ = LOCAL_LABEL_PREFIX;
1499 /* Next code just does sprintf( {}, "%d", n); */
1501 q = symbol_name_temporary;
1502 for (*q++ = 0, i = n; i; ++q)
1507 while ((*p = *--q) != '\0')
1510 *p++ = LOCAL_LABEL_CHAR; /* ^B */
1512 /* Instance number. */
1513 q = symbol_name_temporary;
1514 for (*q++ = 0, i = fb_label_instance (n) + augend; i; ++q)
1519 while ((*p++ = *--q) != '\0');;
1521 /* The label, as a '\0' ended string, starts at symbol_name_build. */
1522 return (symbol_name_build);
1525 /* Decode name that may have been generated by foo_label_name() above.
1526 If the name wasn't generated by foo_label_name(), then return it
1527 unaltered. This is used for error messages. */
1530 decode_local_label_name (s)
1534 char *symbol_decode;
1536 int instance_number;
1538 const char *message_format;
1541 #ifdef LOCAL_LABEL_PREFIX
1542 if (s[index] == LOCAL_LABEL_PREFIX)
1546 if (s[index] != 'L')
1549 for (label_number = 0, p = s + index + 1; isdigit ((unsigned char) *p); ++p)
1550 label_number = (10 * label_number) + *p - '0';
1552 if (*p == DOLLAR_LABEL_CHAR)
1554 else if (*p == LOCAL_LABEL_CHAR)
1559 for (instance_number = 0, p++; isdigit ((unsigned char) *p); ++p)
1560 instance_number = (10 * instance_number) + *p - '0';
1562 message_format = _("\"%d\" (instance number %d of a %s label)");
1563 symbol_decode = obstack_alloc (¬es, strlen (message_format) + 30);
1564 sprintf (symbol_decode, message_format, label_number, instance_number, type);
1566 return symbol_decode;
1569 /* Get the value of a symbol. */
1575 #ifdef BFD_ASSEMBLER
1576 if (LOCAL_SYMBOL_CHECK (s))
1577 return ((struct local_symbol *) s)->lsy_offset;
1580 if (!s->sy_resolved && s->sy_value.X_op != O_constant)
1582 valueT val = resolve_symbol_value (s, finalize_syms);
1583 if (finalize_syms != 2 && S_GET_SEGMENT (s) == expr_section)
1586 if (s->sy_value.X_op != O_constant)
1588 static symbolS *recur;
1590 /* FIXME: In non BFD assemblers, S_IS_DEFINED and S_IS_COMMON
1591 may call S_GET_VALUE. We use a static symbol to avoid the
1592 immediate recursion. */
1594 return (valueT) s->sy_value.X_add_number;
1596 if (! s->sy_resolved
1597 || s->sy_value.X_op != O_symbol
1598 || (S_IS_DEFINED (s) && ! S_IS_COMMON (s)))
1599 as_bad (_("Attempt to get value of unresolved symbol %s"),
1603 return (valueT) s->sy_value.X_add_number;
1606 /* Set the value of a symbol. */
1609 S_SET_VALUE (s, val)
1613 #ifdef BFD_ASSEMBLER
1614 if (LOCAL_SYMBOL_CHECK (s))
1616 ((struct local_symbol *) s)->lsy_offset = val;
1621 s->sy_value.X_op = O_constant;
1622 s->sy_value.X_add_number = (offsetT) val;
1623 s->sy_value.X_unsigned = 0;
1627 copy_symbol_attributes (dest, src)
1628 symbolS *dest, *src;
1630 if (LOCAL_SYMBOL_CHECK (dest))
1631 dest = local_symbol_convert ((struct local_symbol *) dest);
1632 if (LOCAL_SYMBOL_CHECK (src))
1633 src = local_symbol_convert ((struct local_symbol *) src);
1635 #ifdef BFD_ASSEMBLER
1636 /* In an expression, transfer the settings of these flags.
1637 The user can override later, of course. */
1638 #define COPIED_SYMFLAGS (BSF_FUNCTION | BSF_OBJECT)
1639 dest->bsym->flags |= src->bsym->flags & COPIED_SYMFLAGS;
1642 #ifdef OBJ_COPY_SYMBOL_ATTRIBUTES
1643 OBJ_COPY_SYMBOL_ATTRIBUTES (dest, src);
1647 #ifdef BFD_ASSEMBLER
1655 if (LOCAL_SYMBOL_CHECK (s))
1658 flags = s->bsym->flags;
1660 return (flags & BSF_FUNCTION) != 0;
1669 if (LOCAL_SYMBOL_CHECK (s))
1672 flags = s->bsym->flags;
1675 if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL))
1678 return (flags & BSF_GLOBAL) != 0;
1685 if (LOCAL_SYMBOL_CHECK (s))
1687 return (s->bsym->flags & BSF_WEAK) != 0;
1694 if (LOCAL_SYMBOL_CHECK (s))
1696 return bfd_is_com_section (s->bsym->section);
1703 if (LOCAL_SYMBOL_CHECK (s))
1704 return ((struct local_symbol *) s)->lsy_section != undefined_section;
1705 return s->bsym->section != undefined_section;
1712 if (LOCAL_SYMBOL_CHECK (s))
1714 if (s->bsym->flags & BSF_DEBUGGING)
1726 if (LOCAL_SYMBOL_CHECK (s))
1729 flags = s->bsym->flags;
1732 if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL))
1735 if (bfd_get_section (s->bsym) == reg_section)
1738 if (flag_strip_local_absolute
1739 && (flags & BSF_GLOBAL) == 0
1740 && bfd_get_section (s->bsym) == absolute_section)
1743 name = S_GET_NAME (s);
1744 return (name != NULL
1746 && (strchr (name, DOLLAR_LABEL_CHAR)
1747 || strchr (name, LOCAL_LABEL_CHAR)
1748 || (! flag_keep_locals
1749 && (bfd_is_local_label (stdoutput, s->bsym)
1752 && name[1] == '?')))));
1759 return S_IS_EXTERNAL (s);
1766 return S_GET_NAME (s) == 0;
1773 if (LOCAL_SYMBOL_CHECK (s))
1774 return ((struct local_symbol *) s)->lsy_name;
1775 return s->bsym->name;
1782 if (LOCAL_SYMBOL_CHECK (s))
1783 return ((struct local_symbol *) s)->lsy_section;
1784 return s->bsym->section;
1788 S_SET_SEGMENT (s, seg)
1792 /* Don't reassign section symbols. The direct reason is to prevent seg
1793 faults assigning back to const global symbols such as *ABS*, but it
1794 shouldn't happen anyway. */
1796 if (LOCAL_SYMBOL_CHECK (s))
1798 if (seg == reg_section)
1799 s = local_symbol_convert ((struct local_symbol *) s);
1802 ((struct local_symbol *) s)->lsy_section = seg;
1807 if (s->bsym->flags & BSF_SECTION_SYM)
1809 if (s->bsym->section != seg)
1813 s->bsym->section = seg;
1820 if (LOCAL_SYMBOL_CHECK (s))
1821 s = local_symbol_convert ((struct local_symbol *) s);
1822 if ((s->bsym->flags & BSF_WEAK) != 0)
1824 /* Let .weak override .global. */
1827 s->bsym->flags |= BSF_GLOBAL;
1828 s->bsym->flags &= ~(BSF_LOCAL | BSF_WEAK);
1832 S_CLEAR_EXTERNAL (s)
1835 if (LOCAL_SYMBOL_CHECK (s))
1837 if ((s->bsym->flags & BSF_WEAK) != 0)
1839 /* Let .weak override. */
1842 s->bsym->flags |= BSF_LOCAL;
1843 s->bsym->flags &= ~(BSF_GLOBAL | BSF_WEAK);
1850 if (LOCAL_SYMBOL_CHECK (s))
1851 s = local_symbol_convert ((struct local_symbol *) s);
1852 s->bsym->flags |= BSF_WEAK;
1853 s->bsym->flags &= ~(BSF_GLOBAL | BSF_LOCAL);
1857 S_SET_NAME (s, name)
1861 if (LOCAL_SYMBOL_CHECK (s))
1863 ((struct local_symbol *) s)->lsy_name = name;
1866 s->bsym->name = name;
1868 #endif /* BFD_ASSEMBLER */
1870 #ifdef SYMBOLS_NEED_BACKPOINTERS
1872 /* Return the previous symbol in a chain. */
1878 if (LOCAL_SYMBOL_CHECK (s))
1880 return s->sy_previous;
1883 #endif /* SYMBOLS_NEED_BACKPOINTERS */
1885 /* Return the next symbol in a chain. */
1891 if (LOCAL_SYMBOL_CHECK (s))
1896 /* Return a pointer to the value of a symbol as an expression. */
1899 symbol_get_value_expression (s)
1902 if (LOCAL_SYMBOL_CHECK (s))
1903 s = local_symbol_convert ((struct local_symbol *) s);
1904 return &s->sy_value;
1907 /* Set the value of a symbol to an expression. */
1910 symbol_set_value_expression (s, exp)
1912 const expressionS *exp;
1914 if (LOCAL_SYMBOL_CHECK (s))
1915 s = local_symbol_convert ((struct local_symbol *) s);
1919 /* Set the frag of a symbol. */
1922 symbol_set_frag (s, f)
1926 #ifdef BFD_ASSEMBLER
1927 if (LOCAL_SYMBOL_CHECK (s))
1929 local_symbol_set_frag ((struct local_symbol *) s, f);
1936 /* Return the frag of a symbol. */
1942 #ifdef BFD_ASSEMBLER
1943 if (LOCAL_SYMBOL_CHECK (s))
1944 return local_symbol_get_frag ((struct local_symbol *) s);
1949 /* Mark a symbol as having been used. */
1952 symbol_mark_used (s)
1955 if (LOCAL_SYMBOL_CHECK (s))
1960 /* Clear the mark of whether a symbol has been used. */
1963 symbol_clear_used (s)
1966 if (LOCAL_SYMBOL_CHECK (s))
1967 s = local_symbol_convert ((struct local_symbol *) s);
1971 /* Return whether a symbol has been used. */
1977 if (LOCAL_SYMBOL_CHECK (s))
1982 /* Mark a symbol as having been used in a reloc. */
1985 symbol_mark_used_in_reloc (s)
1988 if (LOCAL_SYMBOL_CHECK (s))
1989 s = local_symbol_convert ((struct local_symbol *) s);
1990 s->sy_used_in_reloc = 1;
1993 /* Clear the mark of whether a symbol has been used in a reloc. */
1996 symbol_clear_used_in_reloc (s)
1999 if (LOCAL_SYMBOL_CHECK (s))
2001 s->sy_used_in_reloc = 0;
2004 /* Return whether a symbol has been used in a reloc. */
2007 symbol_used_in_reloc_p (s)
2010 if (LOCAL_SYMBOL_CHECK (s))
2012 return s->sy_used_in_reloc;
2015 /* Mark a symbol as an MRI common symbol. */
2018 symbol_mark_mri_common (s)
2021 if (LOCAL_SYMBOL_CHECK (s))
2022 s = local_symbol_convert ((struct local_symbol *) s);
2023 s->sy_mri_common = 1;
2026 /* Clear the mark of whether a symbol is an MRI common symbol. */
2029 symbol_clear_mri_common (s)
2032 if (LOCAL_SYMBOL_CHECK (s))
2034 s->sy_mri_common = 0;
2037 /* Return whether a symbol is an MRI common symbol. */
2040 symbol_mri_common_p (s)
2043 if (LOCAL_SYMBOL_CHECK (s))
2045 return s->sy_mri_common;
2048 /* Mark a symbol as having been written. */
2051 symbol_mark_written (s)
2054 if (LOCAL_SYMBOL_CHECK (s))
2059 /* Clear the mark of whether a symbol has been written. */
2062 symbol_clear_written (s)
2065 if (LOCAL_SYMBOL_CHECK (s))
2070 /* Return whether a symbol has been written. */
2073 symbol_written_p (s)
2076 if (LOCAL_SYMBOL_CHECK (s))
2081 /* Mark a symbol has having been resolved. */
2084 symbol_mark_resolved (s)
2087 #ifdef BFD_ASSEMBLER
2088 if (LOCAL_SYMBOL_CHECK (s))
2090 local_symbol_mark_resolved ((struct local_symbol *) s);
2097 /* Return whether a symbol has been resolved. */
2100 symbol_resolved_p (s)
2103 #ifdef BFD_ASSEMBLER
2104 if (LOCAL_SYMBOL_CHECK (s))
2105 return local_symbol_resolved_p ((struct local_symbol *) s);
2107 return s->sy_resolved;
2110 /* Return whether a symbol is a section symbol. */
2113 symbol_section_p (s)
2114 symbolS *s ATTRIBUTE_UNUSED;
2116 if (LOCAL_SYMBOL_CHECK (s))
2118 #ifdef BFD_ASSEMBLER
2119 return (s->bsym->flags & BSF_SECTION_SYM) != 0;
2126 /* Return whether a symbol is equated to another symbol. */
2129 symbol_equated_p (s)
2132 if (LOCAL_SYMBOL_CHECK (s))
2134 return s->sy_value.X_op == O_symbol;
2137 /* Return whether a symbol has a constant value. */
2140 symbol_constant_p (s)
2143 if (LOCAL_SYMBOL_CHECK (s))
2145 return s->sy_value.X_op == O_constant;
2148 #ifdef BFD_ASSEMBLER
2150 /* Return the BFD symbol for a symbol. */
2153 symbol_get_bfdsym (s)
2156 if (LOCAL_SYMBOL_CHECK (s))
2157 s = local_symbol_convert ((struct local_symbol *) s);
2161 /* Set the BFD symbol for a symbol. */
2164 symbol_set_bfdsym (s, bsym)
2168 if (LOCAL_SYMBOL_CHECK (s))
2169 s = local_symbol_convert ((struct local_symbol *) s);
2173 #endif /* BFD_ASSEMBLER */
2175 #ifdef OBJ_SYMFIELD_TYPE
2177 /* Get a pointer to the object format information for a symbol. */
2183 if (LOCAL_SYMBOL_CHECK (s))
2184 s = local_symbol_convert ((struct local_symbol *) s);
2188 /* Set the object format information for a symbol. */
2191 symbol_set_obj (s, o)
2193 OBJ_SYMFIELD_TYPE *o;
2195 if (LOCAL_SYMBOL_CHECK (s))
2196 s = local_symbol_convert ((struct local_symbol *) s);
2200 #endif /* OBJ_SYMFIELD_TYPE */
2202 #ifdef TC_SYMFIELD_TYPE
2204 /* Get a pointer to the processor information for a symbol. */
2210 if (LOCAL_SYMBOL_CHECK (s))
2211 s = local_symbol_convert ((struct local_symbol *) s);
2215 /* Set the processor information for a symbol. */
2218 symbol_set_tc (s, o)
2220 TC_SYMFIELD_TYPE *o;
2222 if (LOCAL_SYMBOL_CHECK (s))
2223 s = local_symbol_convert ((struct local_symbol *) s);
2227 #endif /* TC_SYMFIELD_TYPE */
2232 symbol_lastP = NULL;
2233 symbol_rootP = NULL; /* In case we have 0 symbols (!!) */
2234 sy_hash = hash_new ();
2235 #ifdef BFD_ASSEMBLER
2236 local_hash = hash_new ();
2239 memset ((char *) (&abs_symbol), '\0', sizeof (abs_symbol));
2240 #ifdef BFD_ASSEMBLER
2241 #if defined (EMIT_SECTION_SYMBOLS) || !defined (RELOC_REQUIRES_SYMBOL)
2242 abs_symbol.bsym = bfd_abs_section.symbol;
2245 /* Can't initialise a union. Sigh. */
2246 S_SET_SEGMENT (&abs_symbol, absolute_section);
2248 abs_symbol.sy_value.X_op = O_constant;
2249 abs_symbol.sy_frag = &zero_address_frag;
2251 if (LOCAL_LABELS_FB)
2257 /* Maximum indent level.
2258 Available for modification inside a gdb session. */
2259 int max_indent_level = 8;
2266 printf ("%*s", indent_level * 4, "");
2272 print_symbol_value_1 (file, sym)
2276 const char *name = S_GET_NAME (sym);
2277 if (!name || !name[0])
2279 fprintf (file, "sym %lx %s", (unsigned long) sym, name);
2281 if (LOCAL_SYMBOL_CHECK (sym))
2283 #ifdef BFD_ASSEMBLER
2284 struct local_symbol *locsym = (struct local_symbol *) sym;
2285 if (local_symbol_get_frag (locsym) != &zero_address_frag
2286 && local_symbol_get_frag (locsym) != NULL)
2287 fprintf (file, " frag %lx", (long) local_symbol_get_frag (locsym));
2288 if (local_symbol_resolved_p (locsym))
2289 fprintf (file, " resolved");
2290 fprintf (file, " local");
2295 if (sym->sy_frag != &zero_address_frag)
2296 fprintf (file, " frag %lx", (long) sym->sy_frag);
2298 fprintf (file, " written");
2299 if (sym->sy_resolved)
2300 fprintf (file, " resolved");
2301 else if (sym->sy_resolving)
2302 fprintf (file, " resolving");
2303 if (sym->sy_used_in_reloc)
2304 fprintf (file, " used-in-reloc");
2306 fprintf (file, " used");
2307 if (S_IS_LOCAL (sym))
2308 fprintf (file, " local");
2309 if (S_IS_EXTERN (sym))
2310 fprintf (file, " extern");
2311 if (S_IS_DEBUG (sym))
2312 fprintf (file, " debug");
2313 if (S_IS_DEFINED (sym))
2314 fprintf (file, " defined");
2316 fprintf (file, " %s", segment_name (S_GET_SEGMENT (sym)));
2317 if (symbol_resolved_p (sym))
2319 segT s = S_GET_SEGMENT (sym);
2321 if (s != undefined_section
2322 && s != expr_section)
2323 fprintf (file, " %lx", (long) S_GET_VALUE (sym));
2325 else if (indent_level < max_indent_level
2326 && S_GET_SEGMENT (sym) != undefined_section)
2329 fprintf (file, "\n%*s<", indent_level * 4, "");
2330 #ifdef BFD_ASSEMBLER
2331 if (LOCAL_SYMBOL_CHECK (sym))
2332 fprintf (file, "constant %lx",
2333 (long) ((struct local_symbol *) sym)->lsy_offset);
2336 print_expr_1 (file, &sym->sy_value);
2337 fprintf (file, ">");
2344 print_symbol_value (sym)
2348 print_symbol_value_1 (stderr, sym);
2349 fprintf (stderr, "\n");
2353 print_binary (file, name, exp)
2359 fprintf (file, "%s\n%*s<", name, indent_level * 4, "");
2360 print_symbol_value_1 (file, exp->X_add_symbol);
2361 fprintf (file, ">\n%*s<", indent_level * 4, "");
2362 print_symbol_value_1 (file, exp->X_op_symbol);
2363 fprintf (file, ">");
2368 print_expr_1 (file, exp)
2372 fprintf (file, "expr %lx ", (long) exp);
2376 fprintf (file, "illegal");
2379 fprintf (file, "absent");
2382 fprintf (file, "constant %lx", (long) exp->X_add_number);
2386 fprintf (file, "symbol\n%*s<", indent_level * 4, "");
2387 print_symbol_value_1 (file, exp->X_add_symbol);
2388 fprintf (file, ">");
2390 if (exp->X_add_number)
2391 fprintf (file, "\n%*s%lx", indent_level * 4, "",
2392 (long) exp->X_add_number);
2396 fprintf (file, "register #%d", (int) exp->X_add_number);
2399 fprintf (file, "big");
2402 fprintf (file, "uminus -<");
2404 print_symbol_value_1 (file, exp->X_add_symbol);
2405 fprintf (file, ">");
2406 goto maybe_print_addnum;
2408 fprintf (file, "bit_not");
2411 print_binary (file, "multiply", exp);
2414 print_binary (file, "divide", exp);
2417 print_binary (file, "modulus", exp);
2420 print_binary (file, "lshift", exp);
2423 print_binary (file, "rshift", exp);
2425 case O_bit_inclusive_or:
2426 print_binary (file, "bit_ior", exp);
2428 case O_bit_exclusive_or:
2429 print_binary (file, "bit_xor", exp);
2432 print_binary (file, "bit_and", exp);
2435 print_binary (file, "eq", exp);
2438 print_binary (file, "ne", exp);
2441 print_binary (file, "lt", exp);
2444 print_binary (file, "le", exp);
2447 print_binary (file, "ge", exp);
2450 print_binary (file, "gt", exp);
2453 print_binary (file, "logical_and", exp);
2456 print_binary (file, "logical_or", exp);
2460 fprintf (file, "add\n%*s<", indent_level * 4, "");
2461 print_symbol_value_1 (file, exp->X_add_symbol);
2462 fprintf (file, ">\n%*s<", indent_level * 4, "");
2463 print_symbol_value_1 (file, exp->X_op_symbol);
2464 fprintf (file, ">");
2465 goto maybe_print_addnum;
2468 fprintf (file, "subtract\n%*s<", indent_level * 4, "");
2469 print_symbol_value_1 (file, exp->X_add_symbol);
2470 fprintf (file, ">\n%*s<", indent_level * 4, "");
2471 print_symbol_value_1 (file, exp->X_op_symbol);
2472 fprintf (file, ">");
2473 goto maybe_print_addnum;
2475 fprintf (file, "{unknown opcode %d}", (int) exp->X_op);
2485 print_expr_1 (stderr, exp);
2486 fprintf (stderr, "\n");
2490 symbol_print_statistics (file)
2493 hash_print_statistics (file, "symbol table", sy_hash);
2494 #ifdef BFD_ASSEMBLER
2495 hash_print_statistics (file, "mini local symbol table", local_hash);
2496 fprintf (file, "%lu mini local symbols created, %lu converted\n",
2497 local_symbol_count, local_symbol_conversion_count);