1 /* symbols.c -symbol table-
2 Copyright (C) 1987-2020 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to the Free
18 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
21 /* #define DEBUG_SYMS / * to debug symbol list maintenance. */
24 #include "safe-ctype.h"
25 #include "obstack.h" /* For "symbols.h" */
31 /* Whether the symbol is a local_symbol. */
32 unsigned int sy_local_symbol
: 1;
34 /* Weather symbol has been written. */
35 unsigned int sy_written
: 1;
37 /* Whether symbol value has been completely resolved (used during
38 final pass over symbol table). */
39 unsigned int sy_resolved
: 1;
41 /* Whether the symbol value is currently being resolved (used to
42 detect loops in symbol dependencies). */
43 unsigned int sy_resolving
: 1;
45 /* Whether the symbol value is used in a reloc. This is used to
46 ensure that symbols used in relocs are written out, even if they
47 are local and would otherwise not be. */
48 unsigned int sy_used_in_reloc
: 1;
50 /* Whether the symbol is used as an operand or in an expression.
51 NOTE: Not all the backends keep this information accurate;
52 backends which use this bit are responsible for setting it when
53 a symbol is used in backend routines. */
54 unsigned int sy_used
: 1;
56 /* Whether the symbol can be re-defined. */
57 unsigned int sy_volatile
: 1;
59 /* Whether the symbol is a forward reference. */
60 unsigned int sy_forward_ref
: 1;
62 /* This is set if the symbol is defined in an MRI common section.
63 We handle such sections as single common symbols, so symbols
64 defined within them must be treated specially by the relocation
66 unsigned int sy_mri_common
: 1;
68 /* This is set if the symbol is set with a .weakref directive. */
69 unsigned int sy_weakrefr
: 1;
71 /* This is set when the symbol is referenced as part of a .weakref
72 directive, but only if the symbol was not in the symbol table
73 before. It is cleared as soon as any direct reference to the
75 unsigned int sy_weakrefd
: 1;
78 /* The information we keep for a symbol. Note that the symbol table
79 holds pointers both to this and to local_symbol structures. See
85 struct symbol_flags sy_flags
;
90 /* The value of the symbol. */
93 /* Forwards and (optionally) backwards chain pointers. */
94 struct symbol
*sy_next
;
95 struct symbol
*sy_previous
;
97 /* Pointer to the frag this symbol is attached to, if any.
101 #ifdef OBJ_SYMFIELD_TYPE
102 OBJ_SYMFIELD_TYPE sy_obj
;
105 #ifdef TC_SYMFIELD_TYPE
106 TC_SYMFIELD_TYPE sy_tc
;
109 #ifdef TARGET_SYMBOL_FIELDS
114 /* A pointer in the symbol may point to either a complete symbol
115 (struct symbol above) or to a local symbol (struct local_symbol
116 defined here). The symbol code can detect the case by examining
117 the first field which is present in both structs.
119 We do this because we ordinarily only need a small amount of
120 information for a local symbol. The symbol table takes up a lot of
121 space, and storing less information for a local symbol can make a
122 big difference in assembler memory usage when assembling a large
127 /* Symbol flags. Only sy_local_symbol and sy_resolved are relevant. */
128 struct symbol_flags lsy_flags
;
130 /* The symbol section. This also serves as a flag. If this is
131 reg_section, then this symbol has been converted into a regular
132 symbol, and lsy_sym points to it. */
135 /* The symbol name. */
136 const char *lsy_name
;
138 /* The symbol frag or the real symbol, depending upon the value in
146 /* The value of the symbol. */
149 #ifdef TC_LOCAL_SYMFIELD_TYPE
150 TC_LOCAL_SYMFIELD_TYPE lsy_tc
;
154 #define local_symbol_converted_p(l) ((l)->lsy_section == reg_section)
155 #define local_symbol_mark_converted(l) ((l)->lsy_section = reg_section)
156 #define local_symbol_resolved_p(l) ((l)->lsy_flags.sy_resolved)
157 #define local_symbol_mark_resolved(l) ((l)->lsy_flags.sy_resolved = 1)
158 #define local_symbol_get_frag(l) ((l)->u.lsy_frag)
159 #define local_symbol_set_frag(l, f) ((l)->u.lsy_frag = (f))
160 #define local_symbol_get_real_symbol(l) ((l)->u.lsy_sym)
161 #define local_symbol_set_real_symbol(l, s) ((l)->u.lsy_sym = (s))
163 /* This is non-zero if symbols are case sensitive, which is the
165 int symbols_case_sensitive
= 1;
167 #ifndef WORKING_DOT_WORD
168 extern int new_broken_words
;
171 /* symbol-name => struct symbol pointer */
172 static struct hash_control
*sy_hash
;
174 /* Table of local symbols. */
175 static struct hash_control
*local_hash
;
177 /* Below are commented in "symbols.h". */
178 symbolS
*symbol_rootP
;
179 symbolS
*symbol_lastP
;
184 #define debug_verify_symchain verify_symbol_chain
186 #define debug_verify_symchain(root, last) ((void) 0)
189 #define DOLLAR_LABEL_CHAR '\001'
190 #define LOCAL_LABEL_CHAR '\002'
192 #ifndef TC_LABEL_IS_LOCAL
193 #define TC_LABEL_IS_LOCAL(name) 0
196 struct obstack notes
;
198 /* The name of an external symbol which is
199 used to make weak PE symbol names unique. */
200 const char * an_external_name
;
203 static const char *save_symbol_name (const char *);
204 static void fb_label_init (void);
205 static long dollar_label_instance (long);
206 static long fb_label_instance (long);
208 static void print_binary (FILE *, const char *, expressionS
*);
210 /* Return a pointer to a new symbol. Die if we can't make a new
211 symbol. Fill in the symbol's values. Add symbol to end of symbol
214 This function should be called in the general case of creating a
215 symbol. However, if the output file symbol table has already been
216 set, and you are certain that this symbol won't be wanted in the
217 output file, you can call symbol_create. */
220 symbol_new (const char *name
, segT segment
, valueT valu
, fragS
*frag
)
222 symbolS
*symbolP
= symbol_create (name
, segment
, valu
, frag
);
224 /* Link to end of symbol chain. */
226 extern int symbol_table_frozen
;
227 if (symbol_table_frozen
)
230 symbol_append (symbolP
, symbol_lastP
, &symbol_rootP
, &symbol_lastP
);
235 /* Save a symbol name on a permanent obstack, and convert it according
236 to the object file format. */
239 save_symbol_name (const char *name
)
244 gas_assert (name
!= NULL
);
245 name_length
= strlen (name
) + 1; /* +1 for \0. */
246 obstack_grow (¬es
, name
, name_length
);
247 ret
= (char *) obstack_finish (¬es
);
249 #ifdef tc_canonicalize_symbol_name
250 ret
= tc_canonicalize_symbol_name (ret
);
253 if (! symbols_case_sensitive
)
257 for (s
= ret
; *s
!= '\0'; s
++)
265 symbol_create (const char *name
, /* It is copied, the caller can destroy/modify. */
266 segT segment
, /* Segment identifier (SEG_<something>). */
267 valueT valu
, /* Symbol value. */
268 fragS
*frag
/* Associated fragment. */)
270 const char *preserved_copy_of_name
;
273 preserved_copy_of_name
= save_symbol_name (name
);
275 symbolP
= (symbolS
*) obstack_alloc (¬es
, sizeof (symbolS
));
277 /* symbol must be born in some fixed state. This seems as good as any. */
278 memset (symbolP
, 0, sizeof (symbolS
));
280 symbolP
->bsym
= bfd_make_empty_symbol (stdoutput
);
281 if (symbolP
->bsym
== NULL
)
282 as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));
283 S_SET_NAME (symbolP
, preserved_copy_of_name
);
285 S_SET_SEGMENT (symbolP
, segment
);
286 S_SET_VALUE (symbolP
, valu
);
287 symbol_clear_list_pointers (symbolP
);
289 symbolP
->sy_frag
= frag
;
291 obj_symbol_new_hook (symbolP
);
293 #ifdef tc_symbol_new_hook
294 tc_symbol_new_hook (symbolP
);
301 /* Local symbol support. If we can get away with it, we keep only a
302 small amount of information for local symbols. */
304 static symbolS
*local_symbol_convert (struct local_symbol
*);
306 /* Used for statistics. */
308 static unsigned long local_symbol_count
;
309 static unsigned long local_symbol_conversion_count
;
311 /* This macro is called with a symbol argument passed by reference.
312 It returns whether this is a local symbol. If necessary, it
313 changes its argument to the real symbol. */
315 #define LOCAL_SYMBOL_CHECK(s) \
316 (s->sy_flags.sy_local_symbol \
317 ? (local_symbol_converted_p ((struct local_symbol *) s) \
318 ? (s = local_symbol_get_real_symbol ((struct local_symbol *) s), \
323 /* Create a local symbol and insert it into the local hash table. */
325 struct local_symbol
*
326 local_symbol_make (const char *name
, segT section
, valueT val
, fragS
*frag
)
328 const char *name_copy
;
329 struct local_symbol
*ret
;
330 struct symbol_flags flags
= { .sy_local_symbol
= 1, .sy_resolved
= 0 };
332 ++local_symbol_count
;
334 name_copy
= save_symbol_name (name
);
336 ret
= (struct local_symbol
*) obstack_alloc (¬es
, sizeof *ret
);
337 ret
->lsy_flags
= flags
;
338 ret
->lsy_name
= name_copy
;
339 ret
->lsy_section
= section
;
340 local_symbol_set_frag (ret
, frag
);
341 ret
->lsy_value
= val
;
343 hash_jam (local_hash
, name_copy
, (void *) ret
);
348 /* Convert a local symbol into a real symbol. Note that we do not
349 reclaim the space used by the local symbol. */
352 local_symbol_convert (struct local_symbol
*locsym
)
356 gas_assert (locsym
->lsy_flags
.sy_local_symbol
);
357 if (local_symbol_converted_p (locsym
))
358 return local_symbol_get_real_symbol (locsym
);
360 ++local_symbol_conversion_count
;
362 ret
= symbol_new (locsym
->lsy_name
, locsym
->lsy_section
, locsym
->lsy_value
,
363 local_symbol_get_frag (locsym
));
365 if (local_symbol_resolved_p (locsym
))
366 ret
->sy_flags
.sy_resolved
= 1;
368 /* Local symbols are always either defined or used. */
369 ret
->sy_flags
.sy_used
= 1;
371 #ifdef TC_LOCAL_SYMFIELD_CONVERT
372 TC_LOCAL_SYMFIELD_CONVERT (locsym
, ret
);
375 symbol_table_insert (ret
);
377 local_symbol_mark_converted (locsym
);
378 local_symbol_set_real_symbol (locsym
, ret
);
380 hash_jam (local_hash
, locsym
->lsy_name
, NULL
);
386 define_sym_at_dot (symbolS
*symbolP
)
388 symbolP
->sy_frag
= frag_now
;
389 S_SET_VALUE (symbolP
, (valueT
) frag_now_fix ());
390 S_SET_SEGMENT (symbolP
, now_seg
);
393 /* We have just seen "<name>:".
394 Creates a struct symbol unless it already exists.
396 Gripes if we are redefining a symbol incompatibly (and ignores it). */
399 colon (/* Just seen "x:" - rattle symbols & frags. */
400 const char *sym_name
/* Symbol name, as a canonical string. */
401 /* We copy this string: OK to alter later. */)
403 symbolS
*symbolP
; /* Symbol we are working with. */
405 /* Sun local labels go out of scope whenever a non-local symbol is
407 if (LOCAL_LABELS_DOLLAR
408 && !bfd_is_local_label_name (stdoutput
, sym_name
))
409 dollar_label_clear ();
411 #ifndef WORKING_DOT_WORD
412 if (new_broken_words
)
414 struct broken_word
*a
;
419 if (now_seg
== absolute_section
)
421 as_bad (_("cannot define symbol `%s' in absolute section"), sym_name
);
425 possible_bytes
= (md_short_jump_size
426 + new_broken_words
* md_long_jump_size
);
429 frag_opcode
= frag_var (rs_broken_word
,
433 (symbolS
*) broken_words
,
437 /* We want to store the pointer to where to insert the jump
438 table in the fr_opcode of the rs_broken_word frag. This
439 requires a little hackery. */
441 && (frag_tmp
->fr_type
!= rs_broken_word
442 || frag_tmp
->fr_opcode
))
443 frag_tmp
= frag_tmp
->fr_next
;
445 frag_tmp
->fr_opcode
= frag_opcode
;
446 new_broken_words
= 0;
448 for (a
= broken_words
; a
&& a
->dispfrag
== 0; a
= a
->next_broken_word
)
449 a
->dispfrag
= frag_tmp
;
451 #endif /* WORKING_DOT_WORD */
453 #ifdef obj_frob_colon
454 obj_frob_colon (sym_name
);
457 if ((symbolP
= symbol_find (sym_name
)) != 0)
459 S_CLEAR_WEAKREFR (symbolP
);
460 #ifdef RESOLVE_SYMBOL_REDEFINITION
461 if (RESOLVE_SYMBOL_REDEFINITION (symbolP
))
464 /* Now check for undefined symbols. */
465 if (LOCAL_SYMBOL_CHECK (symbolP
))
467 struct local_symbol
*locsym
= (struct local_symbol
*) symbolP
;
469 if (locsym
->lsy_section
!= undefined_section
470 && (local_symbol_get_frag (locsym
) != frag_now
471 || locsym
->lsy_section
!= now_seg
472 || locsym
->lsy_value
!= frag_now_fix ()))
474 as_bad (_("symbol `%s' is already defined"), sym_name
);
478 locsym
->lsy_section
= now_seg
;
479 local_symbol_set_frag (locsym
, frag_now
);
480 locsym
->lsy_value
= frag_now_fix ();
482 else if (!(S_IS_DEFINED (symbolP
) || symbol_equated_p (symbolP
))
483 || S_IS_COMMON (symbolP
)
484 || S_IS_VOLATILE (symbolP
))
486 if (S_IS_VOLATILE (symbolP
))
488 symbolP
= symbol_clone (symbolP
, 1);
489 S_SET_VALUE (symbolP
, 0);
490 S_CLEAR_VOLATILE (symbolP
);
492 if (S_GET_VALUE (symbolP
) == 0)
494 define_sym_at_dot (symbolP
);
497 #endif /* if we have one, it better be zero. */
502 /* There are still several cases to check:
504 A .comm/.lcomm symbol being redefined as initialized
507 A .comm/.lcomm symbol being redefined with a larger
510 This only used to be allowed on VMS gas, but Sun cc
511 on the sparc also depends on it. */
513 if (((!S_IS_DEBUG (symbolP
)
514 && (!S_IS_DEFINED (symbolP
) || S_IS_COMMON (symbolP
))
515 && S_IS_EXTERNAL (symbolP
))
516 || S_GET_SEGMENT (symbolP
) == bss_section
)
517 && (now_seg
== data_section
518 || now_seg
== bss_section
519 || now_seg
== S_GET_SEGMENT (symbolP
)))
521 /* Select which of the 2 cases this is. */
522 if (now_seg
!= data_section
)
524 /* New .comm for prev .comm symbol.
526 If the new size is larger we just change its
527 value. If the new size is smaller, we ignore
529 if (S_GET_VALUE (symbolP
)
530 < ((unsigned) frag_now_fix ()))
532 S_SET_VALUE (symbolP
, (valueT
) frag_now_fix ());
537 /* It is a .comm/.lcomm being converted to initialized
539 define_sym_at_dot (symbolP
);
544 #if (!defined (OBJ_AOUT) && !defined (OBJ_MAYBE_AOUT))
545 static const char *od_buf
= "";
549 if (OUTPUT_FLAVOR
== bfd_target_aout_flavour
)
550 sprintf (od_buf
, "%d.%d.",
551 S_GET_OTHER (symbolP
),
552 S_GET_DESC (symbolP
));
554 as_bad (_("symbol `%s' is already defined as \"%s\"/%s%ld"),
556 segment_name (S_GET_SEGMENT (symbolP
)),
558 (long) S_GET_VALUE (symbolP
));
560 } /* if the undefined symbol has no value */
564 /* Don't blow up if the definition is the same. */
565 if (!(frag_now
== symbolP
->sy_frag
566 && S_GET_VALUE (symbolP
) == frag_now_fix ()
567 && S_GET_SEGMENT (symbolP
) == now_seg
))
569 as_bad (_("symbol `%s' is already defined"), sym_name
);
570 symbolP
= symbol_clone (symbolP
, 0);
571 define_sym_at_dot (symbolP
);
576 else if (! flag_keep_locals
&& bfd_is_local_label_name (stdoutput
, sym_name
))
578 symbolP
= (symbolS
*) local_symbol_make (sym_name
, now_seg
,
579 (valueT
) frag_now_fix (),
584 symbolP
= symbol_new (sym_name
, now_seg
, (valueT
) frag_now_fix (),
587 symbol_table_insert (symbolP
);
590 if (mri_common_symbol
!= NULL
)
592 /* This symbol is actually being defined within an MRI common
593 section. This requires special handling. */
594 if (LOCAL_SYMBOL_CHECK (symbolP
))
595 symbolP
= local_symbol_convert ((struct local_symbol
*) symbolP
);
596 symbolP
->sy_value
.X_op
= O_symbol
;
597 symbolP
->sy_value
.X_add_symbol
= mri_common_symbol
;
598 symbolP
->sy_value
.X_add_number
= S_GET_VALUE (mri_common_symbol
);
599 symbolP
->sy_frag
= &zero_address_frag
;
600 S_SET_SEGMENT (symbolP
, expr_section
);
601 symbolP
->sy_flags
.sy_mri_common
= 1;
605 tc_frob_label (symbolP
);
607 #ifdef obj_frob_label
608 obj_frob_label (symbolP
);
614 /* Die if we can't insert the symbol. */
617 symbol_table_insert (symbolS
*symbolP
)
619 const char *error_string
;
622 know (S_GET_NAME (symbolP
));
624 if (LOCAL_SYMBOL_CHECK (symbolP
))
626 error_string
= hash_jam (local_hash
, S_GET_NAME (symbolP
),
628 if (error_string
!= NULL
)
629 as_fatal (_("inserting \"%s\" into symbol table failed: %s"),
630 S_GET_NAME (symbolP
), error_string
);
634 if ((error_string
= hash_jam (sy_hash
, S_GET_NAME (symbolP
), (void *) symbolP
)))
636 as_fatal (_("inserting \"%s\" into symbol table failed: %s"),
637 S_GET_NAME (symbolP
), error_string
);
641 /* If a symbol name does not exist, create it as undefined, and insert
642 it into the symbol table. Return a pointer to it. */
645 symbol_find_or_make (const char *name
)
649 symbolP
= symbol_find (name
);
653 if (! flag_keep_locals
&& bfd_is_local_label_name (stdoutput
, name
))
655 symbolP
= md_undefined_symbol ((char *) name
);
659 symbolP
= (symbolS
*) local_symbol_make (name
, undefined_section
,
665 symbolP
= symbol_make (name
);
667 symbol_table_insert (symbolP
);
668 } /* if symbol wasn't found */
674 symbol_make (const char *name
)
678 /* Let the machine description default it, e.g. for register names. */
679 symbolP
= md_undefined_symbol ((char *) name
);
682 symbolP
= symbol_new (name
, undefined_section
, (valueT
) 0, &zero_address_frag
);
688 symbol_clone (symbolS
*orgsymP
, int replace
)
691 asymbol
*bsymorg
, *bsymnew
;
693 /* Make sure we never clone the dot special symbol. */
694 gas_assert (orgsymP
!= &dot_symbol
);
696 /* Running local_symbol_convert on a clone that's not the one currently
697 in local_hash would incorrectly replace the hash entry. Thus the
698 symbol must be converted here. Note that the rest of the function
699 depends on not encountering an unconverted symbol. */
700 if (LOCAL_SYMBOL_CHECK (orgsymP
))
701 orgsymP
= local_symbol_convert ((struct local_symbol
*) orgsymP
);
702 bsymorg
= orgsymP
->bsym
;
704 newsymP
= (symbolS
*) obstack_alloc (¬es
, sizeof (*newsymP
));
706 bsymnew
= bfd_make_empty_symbol (bfd_asymbol_bfd (bsymorg
));
708 as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));
709 newsymP
->bsym
= bsymnew
;
710 bsymnew
->name
= bsymorg
->name
;
711 bsymnew
->flags
= bsymorg
->flags
& ~BSF_SECTION_SYM
;
712 bsymnew
->section
= bsymorg
->section
;
713 bfd_copy_private_symbol_data (bfd_asymbol_bfd (bsymorg
), bsymorg
,
714 bfd_asymbol_bfd (bsymnew
), bsymnew
);
716 #ifdef obj_symbol_clone_hook
717 obj_symbol_clone_hook (newsymP
, orgsymP
);
720 #ifdef tc_symbol_clone_hook
721 tc_symbol_clone_hook (newsymP
, orgsymP
);
726 if (symbol_rootP
== orgsymP
)
727 symbol_rootP
= newsymP
;
728 else if (orgsymP
->sy_previous
)
730 orgsymP
->sy_previous
->sy_next
= newsymP
;
731 orgsymP
->sy_previous
= NULL
;
733 if (symbol_lastP
== orgsymP
)
734 symbol_lastP
= newsymP
;
735 else if (orgsymP
->sy_next
)
736 orgsymP
->sy_next
->sy_previous
= newsymP
;
738 /* Symbols that won't be output can't be external. */
739 S_CLEAR_EXTERNAL (orgsymP
);
740 orgsymP
->sy_previous
= orgsymP
->sy_next
= orgsymP
;
741 debug_verify_symchain (symbol_rootP
, symbol_lastP
);
743 symbol_table_insert (newsymP
);
747 /* Symbols that won't be output can't be external. */
748 S_CLEAR_EXTERNAL (newsymP
);
749 newsymP
->sy_previous
= newsymP
->sy_next
= newsymP
;
755 /* If S is a local symbol that has been converted, return the
756 converted symbol. Otherwise return S. */
758 static inline symbolS
*
759 get_real_sym (symbolS
*s
)
762 && s
->sy_flags
.sy_local_symbol
763 && local_symbol_converted_p ((struct local_symbol
*) s
))
764 s
= local_symbol_get_real_symbol ((struct local_symbol
*) s
);
768 /* Referenced symbols, if they are forward references, need to be cloned
769 (without replacing the original) so that the value of the referenced
770 symbols at the point of use is saved by the clone. */
772 #undef symbol_clone_if_forward_ref
774 symbol_clone_if_forward_ref (symbolS
*symbolP
, int is_forward
)
776 if (symbolP
&& !LOCAL_SYMBOL_CHECK (symbolP
))
778 symbolS
*orig_add_symbol
= get_real_sym (symbolP
->sy_value
.X_add_symbol
);
779 symbolS
*orig_op_symbol
= get_real_sym (symbolP
->sy_value
.X_op_symbol
);
780 symbolS
*add_symbol
= orig_add_symbol
;
781 symbolS
*op_symbol
= orig_op_symbol
;
783 if (symbolP
->sy_flags
.sy_forward_ref
)
788 /* assign_symbol() clones volatile symbols; pre-existing expressions
789 hold references to the original instance, but want the current
790 value. Just repeat the lookup. */
791 if (add_symbol
&& S_IS_VOLATILE (add_symbol
))
792 add_symbol
= symbol_find_exact (S_GET_NAME (add_symbol
));
793 if (op_symbol
&& S_IS_VOLATILE (op_symbol
))
794 op_symbol
= symbol_find_exact (S_GET_NAME (op_symbol
));
797 /* Re-using sy_resolving here, as this routine cannot get called from
798 symbol resolution code. */
799 if ((symbolP
->bsym
->section
== expr_section
800 || symbolP
->sy_flags
.sy_forward_ref
)
801 && !symbolP
->sy_flags
.sy_resolving
)
803 symbolP
->sy_flags
.sy_resolving
= 1;
804 add_symbol
= symbol_clone_if_forward_ref (add_symbol
, is_forward
);
805 op_symbol
= symbol_clone_if_forward_ref (op_symbol
, is_forward
);
806 symbolP
->sy_flags
.sy_resolving
= 0;
809 if (symbolP
->sy_flags
.sy_forward_ref
810 || add_symbol
!= orig_add_symbol
811 || op_symbol
!= orig_op_symbol
)
813 if (symbolP
!= &dot_symbol
)
815 symbolP
= symbol_clone (symbolP
, 0);
816 symbolP
->sy_flags
.sy_resolving
= 0;
820 symbolP
= symbol_temp_new_now ();
821 #ifdef tc_new_dot_label
822 tc_new_dot_label (symbolP
);
827 symbolP
->sy_value
.X_add_symbol
= add_symbol
;
828 symbolP
->sy_value
.X_op_symbol
= op_symbol
;
835 symbol_temp_new (segT seg
, valueT ofs
, fragS
*frag
)
837 return symbol_new (FAKE_LABEL_NAME
, seg
, ofs
, frag
);
841 symbol_temp_new_now (void)
843 return symbol_temp_new (now_seg
, frag_now_fix (), frag_now
);
847 symbol_temp_new_now_octets (void)
849 return symbol_temp_new (now_seg
, frag_now_fix_octets (), frag_now
);
853 symbol_temp_make (void)
855 return symbol_make (FAKE_LABEL_NAME
);
858 /* Implement symbol table lookup.
859 In: A symbol's name as a string: '\0' can't be part of a symbol name.
860 Out: NULL if the name was not in the symbol table, else the address
861 of a struct symbol associated with that name. */
864 symbol_find_exact (const char *name
)
866 return symbol_find_exact_noref (name
, 0);
870 symbol_find_exact_noref (const char *name
, int noref
)
872 struct local_symbol
*locsym
;
875 locsym
= (struct local_symbol
*) hash_find (local_hash
, name
);
877 return (symbolS
*) locsym
;
879 sym
= ((symbolS
*) hash_find (sy_hash
, name
));
881 /* Any references to the symbol, except for the reference in
882 .weakref, must clear this flag, such that the symbol does not
883 turn into a weak symbol. Note that we don't have to handle the
884 local_symbol case, since a weakrefd is always promoted out of the
885 local_symbol table when it is turned into a weak symbol. */
887 S_CLEAR_WEAKREFD (sym
);
893 symbol_find (const char *name
)
895 return symbol_find_noref (name
, 0);
899 symbol_find_noref (const char *name
, int noref
)
904 #ifdef tc_canonicalize_symbol_name
906 copy
= xstrdup (name
);
907 name
= tc_canonicalize_symbol_name (copy
);
911 if (! symbols_case_sensitive
)
920 name
= copy
= XNEWVEC (char, strlen (name
) + 1);
922 while ((c
= *orig
++) != '\0')
923 *copy
++ = TOUPPER (c
);
927 copy
= (char *) name
;
930 result
= symbol_find_exact_noref (name
, noref
);
935 /* Once upon a time, symbols were kept in a singly linked list. At
936 least coff needs to be able to rearrange them from time to time, for
937 which a doubly linked list is much more convenient. Loic did these
938 as macros which seemed dangerous to me so they're now functions.
941 /* Link symbol ADDME after symbol TARGET in the chain. */
944 symbol_append (symbolS
*addme
, symbolS
*target
,
945 symbolS
**rootPP
, symbolS
**lastPP
)
947 if (LOCAL_SYMBOL_CHECK (addme
))
949 if (target
!= NULL
&& LOCAL_SYMBOL_CHECK (target
))
954 know (*rootPP
== NULL
);
955 know (*lastPP
== NULL
);
956 addme
->sy_next
= NULL
;
957 addme
->sy_previous
= NULL
;
961 } /* if the list is empty */
963 if (target
->sy_next
!= NULL
)
965 target
->sy_next
->sy_previous
= addme
;
969 know (*lastPP
== target
);
971 } /* if we have a next */
973 addme
->sy_next
= target
->sy_next
;
974 target
->sy_next
= addme
;
975 addme
->sy_previous
= target
;
977 debug_verify_symchain (symbol_rootP
, symbol_lastP
);
980 /* Set the chain pointers of SYMBOL to null. */
983 symbol_clear_list_pointers (symbolS
*symbolP
)
985 if (LOCAL_SYMBOL_CHECK (symbolP
))
987 symbolP
->sy_next
= NULL
;
988 symbolP
->sy_previous
= NULL
;
991 /* Remove SYMBOLP from the list. */
994 symbol_remove (symbolS
*symbolP
, symbolS
**rootPP
, symbolS
**lastPP
)
996 if (LOCAL_SYMBOL_CHECK (symbolP
))
999 if (symbolP
== *rootPP
)
1001 *rootPP
= symbolP
->sy_next
;
1002 } /* if it was the root */
1004 if (symbolP
== *lastPP
)
1006 *lastPP
= symbolP
->sy_previous
;
1007 } /* if it was the tail */
1009 if (symbolP
->sy_next
!= NULL
)
1011 symbolP
->sy_next
->sy_previous
= symbolP
->sy_previous
;
1014 if (symbolP
->sy_previous
!= NULL
)
1016 symbolP
->sy_previous
->sy_next
= symbolP
->sy_next
;
1017 } /* if not first */
1019 debug_verify_symchain (*rootPP
, *lastPP
);
1022 /* Link symbol ADDME before symbol TARGET in the chain. */
1025 symbol_insert (symbolS
*addme
, symbolS
*target
,
1026 symbolS
**rootPP
, symbolS
**lastPP ATTRIBUTE_UNUSED
)
1028 if (LOCAL_SYMBOL_CHECK (addme
))
1030 if (LOCAL_SYMBOL_CHECK (target
))
1033 if (target
->sy_previous
!= NULL
)
1035 target
->sy_previous
->sy_next
= addme
;
1039 know (*rootPP
== target
);
1041 } /* if not first */
1043 addme
->sy_previous
= target
->sy_previous
;
1044 target
->sy_previous
= addme
;
1045 addme
->sy_next
= target
;
1047 debug_verify_symchain (*rootPP
, *lastPP
);
1051 verify_symbol_chain (symbolS
*rootP
, symbolS
*lastP
)
1053 symbolS
*symbolP
= rootP
;
1055 if (symbolP
== NULL
)
1058 for (; symbol_next (symbolP
) != NULL
; symbolP
= symbol_next (symbolP
))
1060 gas_assert (symbolP
->bsym
!= NULL
);
1061 gas_assert (symbolP
->sy_flags
.sy_local_symbol
== 0);
1062 gas_assert (symbolP
->sy_next
->sy_previous
== symbolP
);
1065 gas_assert (lastP
== symbolP
);
1069 symbol_on_chain (symbolS
*s
, symbolS
*rootPP
, symbolS
*lastPP
)
1071 return (!LOCAL_SYMBOL_CHECK (s
)
1072 && ((s
->sy_next
!= s
1073 && s
->sy_next
!= NULL
1074 && s
->sy_next
->sy_previous
== s
)
1076 && ((s
->sy_previous
!= s
1077 && s
->sy_previous
!= NULL
1078 && s
->sy_previous
->sy_next
== s
)
1082 #ifdef OBJ_COMPLEX_RELC
1085 use_complex_relocs_for (symbolS
* symp
)
1087 switch (symp
->sy_value
.X_op
)
1097 case O_bit_inclusive_or
:
1099 case O_bit_exclusive_or
:
1111 if ((S_IS_COMMON (symp
->sy_value
.X_op_symbol
)
1112 || S_IS_LOCAL (symp
->sy_value
.X_op_symbol
))
1113 && S_IS_DEFINED (symp
->sy_value
.X_op_symbol
)
1114 && S_GET_SEGMENT (symp
->sy_value
.X_op_symbol
) != expr_section
)
1121 if ((S_IS_COMMON (symp
->sy_value
.X_add_symbol
)
1122 || S_IS_LOCAL (symp
->sy_value
.X_add_symbol
))
1123 && S_IS_DEFINED (symp
->sy_value
.X_add_symbol
)
1124 && S_GET_SEGMENT (symp
->sy_value
.X_add_symbol
) != expr_section
)
1137 report_op_error (symbolS
*symp
, symbolS
*left
, operatorT op
, symbolS
*right
)
1141 segT seg_left
= left
? S_GET_SEGMENT (left
) : 0;
1142 segT seg_right
= S_GET_SEGMENT (right
);
1151 case O_uminus
: opname
= "-"; break;
1152 case O_bit_not
: opname
= "~"; break;
1153 case O_logical_not
: opname
= "!"; break;
1154 case O_multiply
: opname
= "*"; break;
1155 case O_divide
: opname
= "/"; break;
1156 case O_modulus
: opname
= "%"; break;
1157 case O_left_shift
: opname
= "<<"; break;
1158 case O_right_shift
: opname
= ">>"; break;
1159 case O_bit_inclusive_or
: opname
= "|"; break;
1160 case O_bit_or_not
: opname
= "|~"; break;
1161 case O_bit_exclusive_or
: opname
= "^"; break;
1162 case O_bit_and
: opname
= "&"; break;
1163 case O_add
: opname
= "+"; break;
1164 case O_subtract
: opname
= "-"; break;
1165 case O_eq
: opname
= "=="; break;
1166 case O_ne
: opname
= "!="; break;
1167 case O_lt
: opname
= "<"; break;
1168 case O_le
: opname
= "<="; break;
1169 case O_ge
: opname
= ">="; break;
1170 case O_gt
: opname
= ">"; break;
1171 case O_logical_and
: opname
= "&&"; break;
1172 case O_logical_or
: opname
= "||"; break;
1175 if (expr_symbol_where (symp
, &file
, &line
))
1178 as_bad_where (file
, line
,
1179 _("invalid operands (%s and %s sections) for `%s'"),
1180 seg_left
->name
, seg_right
->name
, opname
);
1182 as_bad_where (file
, line
,
1183 _("invalid operand (%s section) for `%s'"),
1184 seg_right
->name
, opname
);
1188 const char *sname
= S_GET_NAME (symp
);
1191 as_bad (_("invalid operands (%s and %s sections) for `%s' when setting `%s'"),
1192 seg_left
->name
, seg_right
->name
, opname
, sname
);
1194 as_bad (_("invalid operand (%s section) for `%s' when setting `%s'"),
1195 seg_right
->name
, opname
, sname
);
1199 /* Resolve the value of a symbol. This is called during the final
1200 pass over the symbol table to resolve any symbols with complex
1204 resolve_symbol_value (symbolS
*symp
)
1210 if (LOCAL_SYMBOL_CHECK (symp
))
1212 struct local_symbol
*locsym
= (struct local_symbol
*) symp
;
1214 final_val
= locsym
->lsy_value
;
1215 if (local_symbol_resolved_p (locsym
))
1218 /* Symbols whose section has SEC_ELF_OCTETS set,
1219 resolve to octets instead of target bytes. */
1220 if (locsym
->lsy_section
->flags
& SEC_OCTETS
)
1221 final_val
+= local_symbol_get_frag (locsym
)->fr_address
;
1223 final_val
+= (local_symbol_get_frag (locsym
)->fr_address
1228 locsym
->lsy_value
= final_val
;
1229 local_symbol_mark_resolved (locsym
);
1235 if (symp
->sy_flags
.sy_resolved
)
1238 while (symp
->sy_value
.X_op
== O_symbol
)
1240 final_val
+= symp
->sy_value
.X_add_number
;
1241 symp
= symp
->sy_value
.X_add_symbol
;
1242 if (LOCAL_SYMBOL_CHECK (symp
))
1244 struct local_symbol
*locsym
= (struct local_symbol
*) symp
;
1245 final_val
+= locsym
->lsy_value
;
1248 if (!symp
->sy_flags
.sy_resolved
)
1251 if (symp
->sy_value
.X_op
== O_constant
)
1252 final_val
+= symp
->sy_value
.X_add_number
;
1259 final_seg
= S_GET_SEGMENT (symp
);
1261 if (symp
->sy_flags
.sy_resolving
)
1264 as_bad (_("symbol definition loop encountered at `%s'"),
1269 #ifdef OBJ_COMPLEX_RELC
1270 else if (final_seg
== expr_section
1271 && use_complex_relocs_for (symp
))
1273 symbolS
* relc_symbol
= NULL
;
1274 char * relc_symbol_name
= NULL
;
1276 relc_symbol_name
= symbol_relc_make_expr (& symp
->sy_value
);
1278 /* For debugging, print out conversion input & output. */
1280 print_expr (& symp
->sy_value
);
1281 if (relc_symbol_name
)
1282 fprintf (stderr
, "-> relc symbol: %s\n", relc_symbol_name
);
1285 if (relc_symbol_name
!= NULL
)
1286 relc_symbol
= symbol_new (relc_symbol_name
, undefined_section
,
1287 0, & zero_address_frag
);
1289 if (relc_symbol
== NULL
)
1291 as_bad (_("cannot convert expression symbol %s to complex relocation"),
1297 symbol_table_insert (relc_symbol
);
1299 /* S_CLEAR_EXTERNAL (relc_symbol); */
1300 if (symp
->bsym
->flags
& BSF_SRELC
)
1301 relc_symbol
->bsym
->flags
|= BSF_SRELC
;
1303 relc_symbol
->bsym
->flags
|= BSF_RELC
;
1304 /* symp->bsym->flags |= BSF_RELC; */
1305 copy_symbol_attributes (symp
, relc_symbol
);
1306 symp
->sy_value
.X_op
= O_symbol
;
1307 symp
->sy_value
.X_add_symbol
= relc_symbol
;
1308 symp
->sy_value
.X_add_number
= 0;
1313 final_seg
= undefined_section
;
1314 goto exit_dont_set_value
;
1319 symbolS
*add_symbol
, *op_symbol
;
1320 offsetT left
, right
;
1321 segT seg_left
, seg_right
;
1325 symp
->sy_flags
.sy_resolving
= 1;
1327 /* Help out with CSE. */
1328 add_symbol
= symp
->sy_value
.X_add_symbol
;
1329 op_symbol
= symp
->sy_value
.X_op_symbol
;
1330 final_val
= symp
->sy_value
.X_add_number
;
1331 op
= symp
->sy_value
.X_op
;
1344 /* Symbols whose section has SEC_ELF_OCTETS set,
1345 resolve to octets instead of target bytes. */
1346 if (symp
->bsym
->section
->flags
& SEC_OCTETS
)
1347 final_val
+= symp
->sy_frag
->fr_address
;
1349 final_val
+= symp
->sy_frag
->fr_address
/ OCTETS_PER_BYTE
;
1350 if (final_seg
== expr_section
)
1351 final_seg
= absolute_section
;
1360 left
= resolve_symbol_value (add_symbol
);
1361 seg_left
= S_GET_SEGMENT (add_symbol
);
1363 symp
->sy_value
.X_op_symbol
= NULL
;
1366 if (S_IS_WEAKREFR (symp
))
1368 gas_assert (final_val
== 0);
1369 if (S_IS_WEAKREFR (add_symbol
))
1371 gas_assert (add_symbol
->sy_value
.X_op
== O_symbol
1372 && add_symbol
->sy_value
.X_add_number
== 0);
1373 add_symbol
= add_symbol
->sy_value
.X_add_symbol
;
1374 gas_assert (! S_IS_WEAKREFR (add_symbol
));
1375 symp
->sy_value
.X_add_symbol
= add_symbol
;
1379 if (symp
->sy_flags
.sy_mri_common
)
1381 /* This is a symbol inside an MRI common section. The
1382 relocation routines are going to handle it specially.
1383 Don't change the value. */
1384 resolved
= symbol_resolved_p (add_symbol
);
1388 /* Don't leave symbol loops. */
1390 && !LOCAL_SYMBOL_CHECK (add_symbol
)
1391 && add_symbol
->sy_flags
.sy_resolving
)
1394 if (finalize_syms
&& final_val
== 0)
1396 if (LOCAL_SYMBOL_CHECK (add_symbol
))
1397 add_symbol
= local_symbol_convert ((struct local_symbol
*)
1399 copy_symbol_attributes (symp
, add_symbol
);
1402 /* If we have equated this symbol to an undefined or common
1403 symbol, keep X_op set to O_symbol, and don't change
1404 X_add_number. This permits the routine which writes out
1405 relocation to detect this case, and convert the
1406 relocation to be against the symbol to which this symbol
1408 if (seg_left
== undefined_section
1409 || bfd_is_com_section (seg_left
)
1410 #if defined (OBJ_COFF) && defined (TE_PE)
1411 || S_IS_WEAK (add_symbol
)
1414 && ((final_seg
== expr_section
1415 && seg_left
!= expr_section
1416 && seg_left
!= absolute_section
)
1417 || symbol_shadow_p (symp
))))
1421 symp
->sy_value
.X_op
= O_symbol
;
1422 symp
->sy_value
.X_add_symbol
= add_symbol
;
1423 symp
->sy_value
.X_add_number
= final_val
;
1424 /* Use X_op_symbol as a flag. */
1425 symp
->sy_value
.X_op_symbol
= add_symbol
;
1427 final_seg
= seg_left
;
1428 final_val
+= symp
->sy_frag
->fr_address
+ left
;
1429 resolved
= symbol_resolved_p (add_symbol
);
1430 symp
->sy_flags
.sy_resolving
= 0;
1431 goto exit_dont_set_value
;
1435 final_val
+= symp
->sy_frag
->fr_address
+ left
;
1436 if (final_seg
== expr_section
|| final_seg
== undefined_section
)
1437 final_seg
= seg_left
;
1440 resolved
= symbol_resolved_p (add_symbol
);
1441 if (S_IS_WEAKREFR (symp
))
1443 symp
->sy_flags
.sy_resolving
= 0;
1444 goto exit_dont_set_value
;
1451 left
= resolve_symbol_value (add_symbol
);
1452 seg_left
= S_GET_SEGMENT (add_symbol
);
1454 /* By reducing these to the relevant dyadic operator, we get
1455 !S -> S == 0 permitted on anything,
1456 -S -> 0 - S only permitted on absolute
1457 ~S -> S ^ ~0 only permitted on absolute */
1458 if (op
!= O_logical_not
&& seg_left
!= absolute_section
1460 report_op_error (symp
, NULL
, op
, add_symbol
);
1462 if (final_seg
== expr_section
|| final_seg
== undefined_section
)
1463 final_seg
= absolute_section
;
1467 else if (op
== O_logical_not
)
1472 final_val
+= left
+ symp
->sy_frag
->fr_address
;
1474 resolved
= symbol_resolved_p (add_symbol
);
1482 case O_bit_inclusive_or
:
1484 case O_bit_exclusive_or
:
1496 left
= resolve_symbol_value (add_symbol
);
1497 right
= resolve_symbol_value (op_symbol
);
1498 seg_left
= S_GET_SEGMENT (add_symbol
);
1499 seg_right
= S_GET_SEGMENT (op_symbol
);
1501 /* Simplify addition or subtraction of a constant by folding the
1502 constant into X_add_number. */
1505 if (seg_right
== absolute_section
)
1510 else if (seg_left
== absolute_section
)
1513 add_symbol
= op_symbol
;
1515 seg_left
= seg_right
;
1519 else if (op
== O_subtract
)
1521 if (seg_right
== absolute_section
)
1529 /* Equality and non-equality tests are permitted on anything.
1530 Subtraction, and other comparison operators are permitted if
1531 both operands are in the same section. Otherwise, both
1532 operands must be absolute. We already handled the case of
1533 addition or subtraction of a constant above. This will
1534 probably need to be changed for an object file format which
1535 supports arbitrary expressions. */
1536 if (!(seg_left
== absolute_section
1537 && seg_right
== absolute_section
)
1538 && !(op
== O_eq
|| op
== O_ne
)
1539 && !((op
== O_subtract
1540 || op
== O_lt
|| op
== O_le
|| op
== O_ge
|| op
== O_gt
)
1541 && seg_left
== seg_right
1542 && (seg_left
!= undefined_section
1543 || add_symbol
== op_symbol
)))
1545 /* Don't emit messages unless we're finalizing the symbol value,
1546 otherwise we may get the same message multiple times. */
1548 report_op_error (symp
, add_symbol
, op
, op_symbol
);
1549 /* However do not move the symbol into the absolute section
1550 if it cannot currently be resolved - this would confuse
1551 other parts of the assembler into believing that the
1552 expression had been evaluated to zero. */
1558 && (final_seg
== expr_section
|| final_seg
== undefined_section
))
1559 final_seg
= absolute_section
;
1561 /* Check for division by zero. */
1562 if ((op
== O_divide
|| op
== O_modulus
) && right
== 0)
1564 /* If seg_right is not absolute_section, then we've
1565 already issued a warning about using a bad symbol. */
1566 if (seg_right
== absolute_section
&& finalize_syms
)
1571 if (expr_symbol_where (symp
, &file
, &line
))
1572 as_bad_where (file
, line
, _("division by zero"));
1574 as_bad (_("division by zero when setting `%s'"),
1581 switch (symp
->sy_value
.X_op
)
1583 case O_multiply
: left
*= right
; break;
1584 case O_divide
: left
/= right
; break;
1585 case O_modulus
: left
%= right
; break;
1586 case O_left_shift
: left
<<= right
; break;
1587 case O_right_shift
: left
>>= right
; break;
1588 case O_bit_inclusive_or
: left
|= right
; break;
1589 case O_bit_or_not
: left
|= ~right
; break;
1590 case O_bit_exclusive_or
: left
^= right
; break;
1591 case O_bit_and
: left
&= right
; break;
1592 case O_add
: left
+= right
; break;
1593 case O_subtract
: left
-= right
; break;
1596 left
= (left
== right
&& seg_left
== seg_right
1597 && (seg_left
!= undefined_section
1598 || add_symbol
== op_symbol
)
1599 ? ~ (offsetT
) 0 : 0);
1600 if (symp
->sy_value
.X_op
== O_ne
)
1603 case O_lt
: left
= left
< right
? ~ (offsetT
) 0 : 0; break;
1604 case O_le
: left
= left
<= right
? ~ (offsetT
) 0 : 0; break;
1605 case O_ge
: left
= left
>= right
? ~ (offsetT
) 0 : 0; break;
1606 case O_gt
: left
= left
> right
? ~ (offsetT
) 0 : 0; break;
1607 case O_logical_and
: left
= left
&& right
; break;
1608 case O_logical_or
: left
= left
|| right
; break;
1613 /* See PR 20895 for a reproducer. */
1614 as_bad (_("Invalid operation on symbol"));
1615 goto exit_dont_set_value
;
1621 final_val
+= symp
->sy_frag
->fr_address
+ left
;
1622 if (final_seg
== expr_section
|| final_seg
== undefined_section
)
1624 if (seg_left
== undefined_section
1625 || seg_right
== undefined_section
)
1626 final_seg
= undefined_section
;
1627 else if (seg_left
== absolute_section
)
1628 final_seg
= seg_right
;
1630 final_seg
= seg_left
;
1632 resolved
= (symbol_resolved_p (add_symbol
)
1633 && symbol_resolved_p (op_symbol
));
1638 /* Give an error (below) if not in expr_section. We don't
1639 want to worry about expr_section symbols, because they
1640 are fictional (they are created as part of expression
1641 resolution), and any problems may not actually mean
1646 symp
->sy_flags
.sy_resolving
= 0;
1650 S_SET_VALUE (symp
, final_val
);
1652 exit_dont_set_value
:
1653 /* Always set the segment, even if not finalizing the value.
1654 The segment is used to determine whether a symbol is defined. */
1655 S_SET_SEGMENT (symp
, final_seg
);
1657 /* Don't worry if we can't resolve an expr_section symbol. */
1661 symp
->sy_flags
.sy_resolved
= 1;
1662 else if (S_GET_SEGMENT (symp
) != expr_section
)
1664 as_bad (_("can't resolve value for symbol `%s'"),
1666 symp
->sy_flags
.sy_resolved
= 1;
1673 static void resolve_local_symbol (const char *, void *);
1675 /* A static function passed to hash_traverse. */
1678 resolve_local_symbol (const char *key ATTRIBUTE_UNUSED
, void *value
)
1681 resolve_symbol_value ((symbolS
*) value
);
1684 /* Resolve all local symbols. */
1687 resolve_local_symbol_values (void)
1689 hash_traverse (local_hash
, resolve_local_symbol
);
1692 /* Obtain the current value of a symbol without changing any
1693 sub-expressions used. */
1696 snapshot_symbol (symbolS
**symbolPP
, valueT
*valueP
, segT
*segP
, fragS
**fragPP
)
1698 symbolS
*symbolP
= *symbolPP
;
1700 if (LOCAL_SYMBOL_CHECK (symbolP
))
1702 struct local_symbol
*locsym
= (struct local_symbol
*) symbolP
;
1704 *valueP
= locsym
->lsy_value
;
1705 *segP
= locsym
->lsy_section
;
1706 *fragPP
= local_symbol_get_frag (locsym
);
1710 expressionS exp
= symbolP
->sy_value
;
1712 if (!symbolP
->sy_flags
.sy_resolved
&& exp
.X_op
!= O_illegal
)
1716 if (symbolP
->sy_flags
.sy_resolving
)
1718 symbolP
->sy_flags
.sy_resolving
= 1;
1719 resolved
= resolve_expression (&exp
);
1720 symbolP
->sy_flags
.sy_resolving
= 0;
1728 if (!symbol_equated_p (symbolP
))
1733 symbolP
= exp
.X_add_symbol
;
1740 *symbolPP
= symbolP
;
1742 /* A bogus input file can result in resolve_expression()
1743 generating a local symbol, so we have to check again. */
1744 if (LOCAL_SYMBOL_CHECK (symbolP
))
1746 struct local_symbol
*locsym
= (struct local_symbol
*) symbolP
;
1748 *valueP
= locsym
->lsy_value
;
1749 *segP
= locsym
->lsy_section
;
1750 *fragPP
= local_symbol_get_frag (locsym
);
1754 *valueP
= exp
.X_add_number
;
1755 *segP
= symbolP
->bsym
->section
;
1756 *fragPP
= symbolP
->sy_frag
;
1759 if (*segP
== expr_section
)
1762 case O_constant
: *segP
= absolute_section
; break;
1763 case O_register
: *segP
= reg_section
; break;
1771 /* Dollar labels look like a number followed by a dollar sign. Eg, "42$".
1772 They are *really* local. That is, they go out of scope whenever we see a
1773 label that isn't local. Also, like fb labels, there can be multiple
1774 instances of a dollar label. Therefor, we name encode each instance with
1775 the instance number, keep a list of defined symbols separate from the real
1776 symbol table, and we treat these buggers as a sparse array. */
1778 static long *dollar_labels
;
1779 static long *dollar_label_instances
;
1780 static char *dollar_label_defines
;
1781 static unsigned long dollar_label_count
;
1782 static unsigned long dollar_label_max
;
1785 dollar_label_defined (long label
)
1789 know ((dollar_labels
!= NULL
) || (dollar_label_count
== 0));
1791 for (i
= dollar_labels
; i
< dollar_labels
+ dollar_label_count
; ++i
)
1793 return dollar_label_defines
[i
- dollar_labels
];
1795 /* If we get here, label isn't defined. */
1800 dollar_label_instance (long label
)
1804 know ((dollar_labels
!= NULL
) || (dollar_label_count
== 0));
1806 for (i
= dollar_labels
; i
< dollar_labels
+ dollar_label_count
; ++i
)
1808 return (dollar_label_instances
[i
- dollar_labels
]);
1810 /* If we get here, we haven't seen the label before.
1811 Therefore its instance count is zero. */
1816 dollar_label_clear (void)
1818 memset (dollar_label_defines
, '\0', (unsigned int) dollar_label_count
);
1821 #define DOLLAR_LABEL_BUMP_BY 10
1824 define_dollar_label (long label
)
1828 for (i
= dollar_labels
; i
< dollar_labels
+ dollar_label_count
; ++i
)
1831 ++dollar_label_instances
[i
- dollar_labels
];
1832 dollar_label_defines
[i
- dollar_labels
] = 1;
1836 /* If we get to here, we don't have label listed yet. */
1838 if (dollar_labels
== NULL
)
1840 dollar_labels
= XNEWVEC (long, DOLLAR_LABEL_BUMP_BY
);
1841 dollar_label_instances
= XNEWVEC (long, DOLLAR_LABEL_BUMP_BY
);
1842 dollar_label_defines
= XNEWVEC (char, DOLLAR_LABEL_BUMP_BY
);
1843 dollar_label_max
= DOLLAR_LABEL_BUMP_BY
;
1844 dollar_label_count
= 0;
1846 else if (dollar_label_count
== dollar_label_max
)
1848 dollar_label_max
+= DOLLAR_LABEL_BUMP_BY
;
1849 dollar_labels
= XRESIZEVEC (long, dollar_labels
, dollar_label_max
);
1850 dollar_label_instances
= XRESIZEVEC (long, dollar_label_instances
,
1852 dollar_label_defines
= XRESIZEVEC (char, dollar_label_defines
,
1854 } /* if we needed to grow */
1856 dollar_labels
[dollar_label_count
] = label
;
1857 dollar_label_instances
[dollar_label_count
] = 1;
1858 dollar_label_defines
[dollar_label_count
] = 1;
1859 ++dollar_label_count
;
1862 /* Caller must copy returned name: we re-use the area for the next name.
1864 The mth occurrence of label n: is turned into the symbol "Ln^Am"
1865 where n is the label number and m is the instance number. "L" makes
1866 it a label discarded unless debugging and "^A"('\1') ensures no
1867 ordinary symbol SHOULD get the same name as a local label
1868 symbol. The first "4:" is "L4^A1" - the m numbers begin at 1.
1870 fb labels get the same treatment, except that ^B is used in place
1873 char * /* Return local label name. */
1874 dollar_label_name (long n
, /* we just saw "n$:" : n a number. */
1875 int augend
/* 0 for current instance, 1 for new instance. */)
1878 /* Returned to caller, then copied. Used for created names ("4f"). */
1879 static char symbol_name_build
[24];
1882 char symbol_name_temporary
[20]; /* Build up a number, BACKWARDS. */
1885 know (augend
== 0 || augend
== 1);
1886 p
= symbol_name_build
;
1887 #ifdef LOCAL_LABEL_PREFIX
1888 *p
++ = LOCAL_LABEL_PREFIX
;
1892 /* Next code just does sprintf( {}, "%d", n); */
1894 q
= symbol_name_temporary
;
1895 for (*q
++ = 0, i
= n
; i
; ++q
)
1900 while ((*p
= *--q
) != '\0')
1903 *p
++ = DOLLAR_LABEL_CHAR
; /* ^A */
1905 /* Instance number. */
1906 q
= symbol_name_temporary
;
1907 for (*q
++ = 0, i
= dollar_label_instance (n
) + augend
; i
; ++q
)
1912 while ((*p
++ = *--q
) != '\0');
1914 /* The label, as a '\0' ended string, starts at symbol_name_build. */
1915 return symbol_name_build
;
1918 /* Somebody else's idea of local labels. They are made by "n:" where n
1919 is any decimal digit. Refer to them with
1920 "nb" for previous (backward) n:
1921 or "nf" for next (forward) n:.
1923 We do a little better and let n be any number, not just a single digit, but
1924 since the other guy's assembler only does ten, we treat the first ten
1927 Like someone else's assembler, we have one set of local label counters for
1928 entire assembly, not one set per (sub)segment like in most assemblers. This
1929 implies that one can refer to a label in another segment, and indeed some
1930 crufty compilers have done just that.
1932 Since there could be a LOT of these things, treat them as a sparse
1935 #define FB_LABEL_SPECIAL (10)
1937 static long fb_low_counter
[FB_LABEL_SPECIAL
];
1938 static long *fb_labels
;
1939 static long *fb_label_instances
;
1940 static long fb_label_count
;
1941 static long fb_label_max
;
1943 /* This must be more than FB_LABEL_SPECIAL. */
1944 #define FB_LABEL_BUMP_BY (FB_LABEL_SPECIAL + 6)
1947 fb_label_init (void)
1949 memset ((void *) fb_low_counter
, '\0', sizeof (fb_low_counter
));
1952 /* Add one to the instance number of this fb label. */
1955 fb_label_instance_inc (long label
)
1959 if ((unsigned long) label
< FB_LABEL_SPECIAL
)
1961 ++fb_low_counter
[label
];
1965 if (fb_labels
!= NULL
)
1967 for (i
= fb_labels
+ FB_LABEL_SPECIAL
;
1968 i
< fb_labels
+ fb_label_count
; ++i
)
1972 ++fb_label_instances
[i
- fb_labels
];
1974 } /* if we find it */
1975 } /* for each existing label */
1978 /* If we get to here, we don't have label listed yet. */
1980 if (fb_labels
== NULL
)
1982 fb_labels
= XNEWVEC (long, FB_LABEL_BUMP_BY
);
1983 fb_label_instances
= XNEWVEC (long, FB_LABEL_BUMP_BY
);
1984 fb_label_max
= FB_LABEL_BUMP_BY
;
1985 fb_label_count
= FB_LABEL_SPECIAL
;
1988 else if (fb_label_count
== fb_label_max
)
1990 fb_label_max
+= FB_LABEL_BUMP_BY
;
1991 fb_labels
= XRESIZEVEC (long, fb_labels
, fb_label_max
);
1992 fb_label_instances
= XRESIZEVEC (long, fb_label_instances
, fb_label_max
);
1993 } /* if we needed to grow */
1995 fb_labels
[fb_label_count
] = label
;
1996 fb_label_instances
[fb_label_count
] = 1;
2001 fb_label_instance (long label
)
2005 if ((unsigned long) label
< FB_LABEL_SPECIAL
)
2007 return (fb_low_counter
[label
]);
2010 if (fb_labels
!= NULL
)
2012 for (i
= fb_labels
+ FB_LABEL_SPECIAL
;
2013 i
< fb_labels
+ fb_label_count
; ++i
)
2017 return (fb_label_instances
[i
- fb_labels
]);
2018 } /* if we find it */
2019 } /* for each existing label */
2022 /* We didn't find the label, so this must be a reference to the
2027 /* Caller must copy returned name: we re-use the area for the next name.
2029 The mth occurrence of label n: is turned into the symbol "Ln^Bm"
2030 where n is the label number and m is the instance number. "L" makes
2031 it a label discarded unless debugging and "^B"('\2') ensures no
2032 ordinary symbol SHOULD get the same name as a local label
2033 symbol. The first "4:" is "L4^B1" - the m numbers begin at 1.
2035 dollar labels get the same treatment, except that ^A is used in
2038 char * /* Return local label name. */
2039 fb_label_name (long n
, /* We just saw "n:", "nf" or "nb" : n a number. */
2040 long augend
/* 0 for nb, 1 for n:, nf. */)
2043 /* Returned to caller, then copied. Used for created names ("4f"). */
2044 static char symbol_name_build
[24];
2047 char symbol_name_temporary
[20]; /* Build up a number, BACKWARDS. */
2051 know ((unsigned long) augend
<= 2 /* See mmix_fb_label. */);
2053 know ((unsigned long) augend
<= 1);
2055 p
= symbol_name_build
;
2056 #ifdef LOCAL_LABEL_PREFIX
2057 *p
++ = LOCAL_LABEL_PREFIX
;
2061 /* Next code just does sprintf( {}, "%d", n); */
2063 q
= symbol_name_temporary
;
2064 for (*q
++ = 0, i
= n
; i
; ++q
)
2069 while ((*p
= *--q
) != '\0')
2072 *p
++ = LOCAL_LABEL_CHAR
; /* ^B */
2074 /* Instance number. */
2075 q
= symbol_name_temporary
;
2076 for (*q
++ = 0, i
= fb_label_instance (n
) + augend
; i
; ++q
)
2081 while ((*p
++ = *--q
) != '\0');
2083 /* The label, as a '\0' ended string, starts at symbol_name_build. */
2084 return (symbol_name_build
);
2087 /* Decode name that may have been generated by foo_label_name() above.
2088 If the name wasn't generated by foo_label_name(), then return it
2089 unaltered. This is used for error messages. */
2092 decode_local_label_name (char *s
)
2095 char *symbol_decode
;
2097 int instance_number
;
2099 const char *message_format
;
2102 #ifdef LOCAL_LABEL_PREFIX
2103 if (s
[lindex
] == LOCAL_LABEL_PREFIX
)
2107 if (s
[lindex
] != 'L')
2110 for (label_number
= 0, p
= s
+ lindex
+ 1; ISDIGIT (*p
); ++p
)
2111 label_number
= (10 * label_number
) + *p
- '0';
2113 if (*p
== DOLLAR_LABEL_CHAR
)
2115 else if (*p
== LOCAL_LABEL_CHAR
)
2120 for (instance_number
= 0, p
++; ISDIGIT (*p
); ++p
)
2121 instance_number
= (10 * instance_number
) + *p
- '0';
2123 message_format
= _("\"%d\" (instance number %d of a %s label)");
2124 symbol_decode
= (char *) obstack_alloc (¬es
, strlen (message_format
) + 30);
2125 sprintf (symbol_decode
, message_format
, label_number
, instance_number
, type
);
2127 return symbol_decode
;
2130 /* Get the value of a symbol. */
2133 S_GET_VALUE (symbolS
*s
)
2135 if (LOCAL_SYMBOL_CHECK (s
))
2136 return resolve_symbol_value (s
);
2138 if (!s
->sy_flags
.sy_resolved
)
2140 valueT val
= resolve_symbol_value (s
);
2144 if (S_IS_WEAKREFR (s
))
2145 return S_GET_VALUE (s
->sy_value
.X_add_symbol
);
2147 if (s
->sy_value
.X_op
!= O_constant
)
2149 if (! s
->sy_flags
.sy_resolved
2150 || s
->sy_value
.X_op
!= O_symbol
2151 || (S_IS_DEFINED (s
) && ! S_IS_COMMON (s
)))
2152 as_bad (_("attempt to get value of unresolved symbol `%s'"),
2155 return (valueT
) s
->sy_value
.X_add_number
;
2158 /* Set the value of a symbol. */
2161 S_SET_VALUE (symbolS
*s
, valueT val
)
2163 if (LOCAL_SYMBOL_CHECK (s
))
2165 ((struct local_symbol
*) s
)->lsy_value
= val
;
2169 s
->sy_value
.X_op
= O_constant
;
2170 s
->sy_value
.X_add_number
= (offsetT
) val
;
2171 s
->sy_value
.X_unsigned
= 0;
2172 S_CLEAR_WEAKREFR (s
);
2176 copy_symbol_attributes (symbolS
*dest
, symbolS
*src
)
2178 if (LOCAL_SYMBOL_CHECK (dest
))
2179 dest
= local_symbol_convert ((struct local_symbol
*) dest
);
2180 if (LOCAL_SYMBOL_CHECK (src
))
2181 src
= local_symbol_convert ((struct local_symbol
*) src
);
2183 /* In an expression, transfer the settings of these flags.
2184 The user can override later, of course. */
2185 #define COPIED_SYMFLAGS (BSF_FUNCTION | BSF_OBJECT \
2186 | BSF_GNU_INDIRECT_FUNCTION)
2187 dest
->bsym
->flags
|= src
->bsym
->flags
& COPIED_SYMFLAGS
;
2189 #ifdef OBJ_COPY_SYMBOL_ATTRIBUTES
2190 OBJ_COPY_SYMBOL_ATTRIBUTES (dest
, src
);
2193 #ifdef TC_COPY_SYMBOL_ATTRIBUTES
2194 TC_COPY_SYMBOL_ATTRIBUTES (dest
, src
);
2199 S_IS_FUNCTION (symbolS
*s
)
2203 if (LOCAL_SYMBOL_CHECK (s
))
2206 flags
= s
->bsym
->flags
;
2208 return (flags
& BSF_FUNCTION
) != 0;
2212 S_IS_EXTERNAL (symbolS
*s
)
2216 if (LOCAL_SYMBOL_CHECK (s
))
2219 flags
= s
->bsym
->flags
;
2222 if ((flags
& BSF_LOCAL
) && (flags
& BSF_GLOBAL
))
2225 return (flags
& BSF_GLOBAL
) != 0;
2229 S_IS_WEAK (symbolS
*s
)
2231 if (LOCAL_SYMBOL_CHECK (s
))
2233 /* Conceptually, a weakrefr is weak if the referenced symbol is. We
2234 could probably handle a WEAKREFR as always weak though. E.g., if
2235 the referenced symbol has lost its weak status, there's no reason
2236 to keep handling the weakrefr as if it was weak. */
2237 if (S_IS_WEAKREFR (s
))
2238 return S_IS_WEAK (s
->sy_value
.X_add_symbol
);
2239 return (s
->bsym
->flags
& BSF_WEAK
) != 0;
2243 S_IS_WEAKREFR (symbolS
*s
)
2245 if (LOCAL_SYMBOL_CHECK (s
))
2247 return s
->sy_flags
.sy_weakrefr
!= 0;
2251 S_IS_WEAKREFD (symbolS
*s
)
2253 if (LOCAL_SYMBOL_CHECK (s
))
2255 return s
->sy_flags
.sy_weakrefd
!= 0;
2259 S_IS_COMMON (symbolS
*s
)
2261 if (LOCAL_SYMBOL_CHECK (s
))
2263 return bfd_is_com_section (s
->bsym
->section
);
2267 S_IS_DEFINED (symbolS
*s
)
2269 if (LOCAL_SYMBOL_CHECK (s
))
2270 return ((struct local_symbol
*) s
)->lsy_section
!= undefined_section
;
2271 return s
->bsym
->section
!= undefined_section
;
2275 #ifndef EXTERN_FORCE_RELOC
2276 #define EXTERN_FORCE_RELOC IS_ELF
2279 /* Return true for symbols that should not be reduced to section
2280 symbols or eliminated from expressions, because they may be
2281 overridden by the linker. */
2283 S_FORCE_RELOC (symbolS
*s
, int strict
)
2286 if (LOCAL_SYMBOL_CHECK (s
))
2287 sec
= ((struct local_symbol
*) s
)->lsy_section
;
2291 && ((s
->bsym
->flags
& BSF_WEAK
) != 0
2292 || (EXTERN_FORCE_RELOC
2293 && (s
->bsym
->flags
& BSF_GLOBAL
) != 0)))
2294 || (s
->bsym
->flags
& BSF_GNU_INDIRECT_FUNCTION
) != 0)
2296 sec
= s
->bsym
->section
;
2298 return bfd_is_und_section (sec
) || bfd_is_com_section (sec
);
2302 S_IS_DEBUG (symbolS
*s
)
2304 if (LOCAL_SYMBOL_CHECK (s
))
2306 if (s
->bsym
->flags
& BSF_DEBUGGING
)
2312 S_IS_LOCAL (symbolS
*s
)
2317 if (LOCAL_SYMBOL_CHECK (s
))
2320 flags
= s
->bsym
->flags
;
2323 if ((flags
& BSF_LOCAL
) && (flags
& BSF_GLOBAL
))
2326 if (bfd_asymbol_section (s
->bsym
) == reg_section
)
2329 if (flag_strip_local_absolute
2330 /* Keep BSF_FILE symbols in order to allow debuggers to identify
2331 the source file even when the object file is stripped. */
2332 && (flags
& (BSF_GLOBAL
| BSF_FILE
)) == 0
2333 && bfd_asymbol_section (s
->bsym
) == absolute_section
)
2336 name
= S_GET_NAME (s
);
2337 return (name
!= NULL
2339 && (strchr (name
, DOLLAR_LABEL_CHAR
)
2340 || strchr (name
, LOCAL_LABEL_CHAR
)
2341 #if FAKE_LABEL_CHAR != DOLLAR_LABEL_CHAR
2342 || strchr (name
, FAKE_LABEL_CHAR
)
2344 || TC_LABEL_IS_LOCAL (name
)
2345 || (! flag_keep_locals
2346 && (bfd_is_local_label (stdoutput
, s
->bsym
)
2349 && name
[1] == '?')))));
2353 S_IS_STABD (symbolS
*s
)
2355 return S_GET_NAME (s
) == 0;
2359 S_CAN_BE_REDEFINED (const symbolS
*s
)
2361 if (LOCAL_SYMBOL_CHECK (s
))
2362 return (local_symbol_get_frag ((struct local_symbol
*) s
)
2363 == &predefined_address_frag
);
2364 /* Permit register names to be redefined. */
2365 return s
->bsym
->section
== reg_section
;
2369 S_IS_VOLATILE (const symbolS
*s
)
2371 if (LOCAL_SYMBOL_CHECK (s
))
2373 return s
->sy_flags
.sy_volatile
;
2377 S_IS_FORWARD_REF (const symbolS
*s
)
2379 if (LOCAL_SYMBOL_CHECK (s
))
2381 return s
->sy_flags
.sy_forward_ref
;
2385 S_GET_NAME (symbolS
*s
)
2387 if (LOCAL_SYMBOL_CHECK (s
))
2388 return ((struct local_symbol
*) s
)->lsy_name
;
2389 return s
->bsym
->name
;
2393 S_GET_SEGMENT (symbolS
*s
)
2395 if (LOCAL_SYMBOL_CHECK (s
))
2396 return ((struct local_symbol
*) s
)->lsy_section
;
2397 return s
->bsym
->section
;
2401 S_SET_SEGMENT (symbolS
*s
, segT seg
)
2403 /* Don't reassign section symbols. The direct reason is to prevent seg
2404 faults assigning back to const global symbols such as *ABS*, but it
2405 shouldn't happen anyway. */
2407 if (LOCAL_SYMBOL_CHECK (s
))
2409 if (seg
== reg_section
)
2410 s
= local_symbol_convert ((struct local_symbol
*) s
);
2413 ((struct local_symbol
*) s
)->lsy_section
= seg
;
2418 if (s
->bsym
->flags
& BSF_SECTION_SYM
)
2420 if (s
->bsym
->section
!= seg
)
2424 s
->bsym
->section
= seg
;
2428 S_SET_EXTERNAL (symbolS
*s
)
2430 if (LOCAL_SYMBOL_CHECK (s
))
2431 s
= local_symbol_convert ((struct local_symbol
*) s
);
2432 if ((s
->bsym
->flags
& BSF_WEAK
) != 0)
2434 /* Let .weak override .global. */
2437 if (s
->bsym
->flags
& BSF_SECTION_SYM
)
2439 /* Do not reassign section symbols. */
2440 as_warn (_("section symbols are already global"));
2443 #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
2444 if (S_GET_SEGMENT (s
) == reg_section
)
2446 as_bad ("can't make register symbol `%s' global",
2451 s
->bsym
->flags
|= BSF_GLOBAL
;
2452 s
->bsym
->flags
&= ~(BSF_LOCAL
| BSF_WEAK
);
2455 if (! an_external_name
&& S_GET_NAME(s
)[0] != '.')
2456 an_external_name
= S_GET_NAME (s
);
2461 S_CLEAR_EXTERNAL (symbolS
*s
)
2463 if (LOCAL_SYMBOL_CHECK (s
))
2465 if ((s
->bsym
->flags
& BSF_WEAK
) != 0)
2467 /* Let .weak override. */
2470 s
->bsym
->flags
|= BSF_LOCAL
;
2471 s
->bsym
->flags
&= ~(BSF_GLOBAL
| BSF_WEAK
);
2475 S_SET_WEAK (symbolS
*s
)
2477 if (LOCAL_SYMBOL_CHECK (s
))
2478 s
= local_symbol_convert ((struct local_symbol
*) s
);
2479 #ifdef obj_set_weak_hook
2480 obj_set_weak_hook (s
);
2482 s
->bsym
->flags
|= BSF_WEAK
;
2483 s
->bsym
->flags
&= ~(BSF_GLOBAL
| BSF_LOCAL
);
2487 S_SET_WEAKREFR (symbolS
*s
)
2489 if (LOCAL_SYMBOL_CHECK (s
))
2490 s
= local_symbol_convert ((struct local_symbol
*) s
);
2491 s
->sy_flags
.sy_weakrefr
= 1;
2492 /* If the alias was already used, make sure we mark the target as
2493 used as well, otherwise it might be dropped from the symbol
2494 table. This may have unintended side effects if the alias is
2495 later redirected to another symbol, such as keeping the unused
2496 previous target in the symbol table. Since it will be weak, it's
2498 if (s
->sy_flags
.sy_used
)
2499 symbol_mark_used (s
->sy_value
.X_add_symbol
);
2503 S_CLEAR_WEAKREFR (symbolS
*s
)
2505 if (LOCAL_SYMBOL_CHECK (s
))
2507 s
->sy_flags
.sy_weakrefr
= 0;
2511 S_SET_WEAKREFD (symbolS
*s
)
2513 if (LOCAL_SYMBOL_CHECK (s
))
2514 s
= local_symbol_convert ((struct local_symbol
*) s
);
2515 s
->sy_flags
.sy_weakrefd
= 1;
2520 S_CLEAR_WEAKREFD (symbolS
*s
)
2522 if (LOCAL_SYMBOL_CHECK (s
))
2524 if (s
->sy_flags
.sy_weakrefd
)
2526 s
->sy_flags
.sy_weakrefd
= 0;
2527 /* If a weakref target symbol is weak, then it was never
2528 referenced directly before, not even in a .global directive,
2529 so decay it to local. If it remains undefined, it will be
2530 later turned into a global, like any other undefined
2532 if (s
->bsym
->flags
& BSF_WEAK
)
2534 #ifdef obj_clear_weak_hook
2535 obj_clear_weak_hook (s
);
2537 s
->bsym
->flags
&= ~BSF_WEAK
;
2538 s
->bsym
->flags
|= BSF_LOCAL
;
2544 S_SET_THREAD_LOCAL (symbolS
*s
)
2546 if (LOCAL_SYMBOL_CHECK (s
))
2547 s
= local_symbol_convert ((struct local_symbol
*) s
);
2548 if (bfd_is_com_section (s
->bsym
->section
)
2549 && (s
->bsym
->flags
& BSF_THREAD_LOCAL
) != 0)
2551 s
->bsym
->flags
|= BSF_THREAD_LOCAL
;
2552 if ((s
->bsym
->flags
& BSF_FUNCTION
) != 0)
2553 as_bad (_("Accessing function `%s' as thread-local object"),
2555 else if (! bfd_is_und_section (s
->bsym
->section
)
2556 && (s
->bsym
->section
->flags
& SEC_THREAD_LOCAL
) == 0)
2557 as_bad (_("Accessing `%s' as thread-local object"),
2562 S_SET_NAME (symbolS
*s
, const char *name
)
2564 if (LOCAL_SYMBOL_CHECK (s
))
2566 ((struct local_symbol
*) s
)->lsy_name
= name
;
2569 s
->bsym
->name
= name
;
2573 S_SET_VOLATILE (symbolS
*s
)
2575 if (LOCAL_SYMBOL_CHECK (s
))
2576 s
= local_symbol_convert ((struct local_symbol
*) s
);
2577 s
->sy_flags
.sy_volatile
= 1;
2581 S_CLEAR_VOLATILE (symbolS
*s
)
2583 if (!LOCAL_SYMBOL_CHECK (s
))
2584 s
->sy_flags
.sy_volatile
= 0;
2588 S_SET_FORWARD_REF (symbolS
*s
)
2590 if (LOCAL_SYMBOL_CHECK (s
))
2591 s
= local_symbol_convert ((struct local_symbol
*) s
);
2592 s
->sy_flags
.sy_forward_ref
= 1;
2595 /* Return the previous symbol in a chain. */
2598 symbol_previous (symbolS
*s
)
2600 if (LOCAL_SYMBOL_CHECK (s
))
2602 return s
->sy_previous
;
2605 /* Return the next symbol in a chain. */
2608 symbol_next (symbolS
*s
)
2610 if (LOCAL_SYMBOL_CHECK (s
))
2615 /* Return a pointer to the value of a symbol as an expression. */
2618 symbol_get_value_expression (symbolS
*s
)
2620 if (LOCAL_SYMBOL_CHECK (s
))
2621 s
= local_symbol_convert ((struct local_symbol
*) s
);
2622 return &s
->sy_value
;
2625 /* Set the value of a symbol to an expression. */
2628 symbol_set_value_expression (symbolS
*s
, const expressionS
*exp
)
2630 if (LOCAL_SYMBOL_CHECK (s
))
2631 s
= local_symbol_convert ((struct local_symbol
*) s
);
2633 S_CLEAR_WEAKREFR (s
);
2636 /* Return whether 2 symbols are the same. */
2639 symbol_same_p (symbolS
*s1
, symbolS
*s2
)
2641 s1
= get_real_sym (s1
);
2642 s2
= get_real_sym (s2
);
2646 /* Return a pointer to the X_add_number component of a symbol. */
2649 symbol_X_add_number (symbolS
*s
)
2651 if (LOCAL_SYMBOL_CHECK (s
))
2652 return (offsetT
*) &((struct local_symbol
*) s
)->lsy_value
;
2654 return &s
->sy_value
.X_add_number
;
2657 /* Set the value of SYM to the current position in the current segment. */
2660 symbol_set_value_now (symbolS
*sym
)
2662 S_SET_SEGMENT (sym
, now_seg
);
2663 S_SET_VALUE (sym
, frag_now_fix ());
2664 symbol_set_frag (sym
, frag_now
);
2667 /* Set the frag of a symbol. */
2670 symbol_set_frag (symbolS
*s
, fragS
*f
)
2672 if (LOCAL_SYMBOL_CHECK (s
))
2674 local_symbol_set_frag ((struct local_symbol
*) s
, f
);
2678 S_CLEAR_WEAKREFR (s
);
2681 /* Return the frag of a symbol. */
2684 symbol_get_frag (symbolS
*s
)
2686 if (LOCAL_SYMBOL_CHECK (s
))
2687 return local_symbol_get_frag ((struct local_symbol
*) s
);
2691 /* Mark a symbol as having been used. */
2694 symbol_mark_used (symbolS
*s
)
2696 if (LOCAL_SYMBOL_CHECK (s
))
2698 s
->sy_flags
.sy_used
= 1;
2699 if (S_IS_WEAKREFR (s
))
2700 symbol_mark_used (s
->sy_value
.X_add_symbol
);
2703 /* Clear the mark of whether a symbol has been used. */
2706 symbol_clear_used (symbolS
*s
)
2708 if (LOCAL_SYMBOL_CHECK (s
))
2709 s
= local_symbol_convert ((struct local_symbol
*) s
);
2710 s
->sy_flags
.sy_used
= 0;
2713 /* Return whether a symbol has been used. */
2716 symbol_used_p (symbolS
*s
)
2718 if (LOCAL_SYMBOL_CHECK (s
))
2720 return s
->sy_flags
.sy_used
;
2723 /* Mark a symbol as having been used in a reloc. */
2726 symbol_mark_used_in_reloc (symbolS
*s
)
2728 if (LOCAL_SYMBOL_CHECK (s
))
2729 s
= local_symbol_convert ((struct local_symbol
*) s
);
2730 s
->sy_flags
.sy_used_in_reloc
= 1;
2733 /* Clear the mark of whether a symbol has been used in a reloc. */
2736 symbol_clear_used_in_reloc (symbolS
*s
)
2738 if (LOCAL_SYMBOL_CHECK (s
))
2740 s
->sy_flags
.sy_used_in_reloc
= 0;
2743 /* Return whether a symbol has been used in a reloc. */
2746 symbol_used_in_reloc_p (symbolS
*s
)
2748 if (LOCAL_SYMBOL_CHECK (s
))
2750 return s
->sy_flags
.sy_used_in_reloc
;
2753 /* Mark a symbol as an MRI common symbol. */
2756 symbol_mark_mri_common (symbolS
*s
)
2758 if (LOCAL_SYMBOL_CHECK (s
))
2759 s
= local_symbol_convert ((struct local_symbol
*) s
);
2760 s
->sy_flags
.sy_mri_common
= 1;
2763 /* Clear the mark of whether a symbol is an MRI common symbol. */
2766 symbol_clear_mri_common (symbolS
*s
)
2768 if (LOCAL_SYMBOL_CHECK (s
))
2770 s
->sy_flags
.sy_mri_common
= 0;
2773 /* Return whether a symbol is an MRI common symbol. */
2776 symbol_mri_common_p (symbolS
*s
)
2778 if (LOCAL_SYMBOL_CHECK (s
))
2780 return s
->sy_flags
.sy_mri_common
;
2783 /* Mark a symbol as having been written. */
2786 symbol_mark_written (symbolS
*s
)
2788 if (LOCAL_SYMBOL_CHECK (s
))
2790 s
->sy_flags
.sy_written
= 1;
2793 /* Clear the mark of whether a symbol has been written. */
2796 symbol_clear_written (symbolS
*s
)
2798 if (LOCAL_SYMBOL_CHECK (s
))
2800 s
->sy_flags
.sy_written
= 0;
2803 /* Return whether a symbol has been written. */
2806 symbol_written_p (symbolS
*s
)
2808 if (LOCAL_SYMBOL_CHECK (s
))
2810 return s
->sy_flags
.sy_written
;
2813 /* Mark a symbol has having been resolved. */
2816 symbol_mark_resolved (symbolS
*s
)
2818 if (LOCAL_SYMBOL_CHECK (s
))
2820 local_symbol_mark_resolved ((struct local_symbol
*) s
);
2823 s
->sy_flags
.sy_resolved
= 1;
2826 /* Return whether a symbol has been resolved. */
2829 symbol_resolved_p (symbolS
*s
)
2831 if (LOCAL_SYMBOL_CHECK (s
))
2832 return local_symbol_resolved_p ((struct local_symbol
*) s
);
2833 return s
->sy_flags
.sy_resolved
;
2836 /* Return whether a symbol is a section symbol. */
2839 symbol_section_p (symbolS
*s ATTRIBUTE_UNUSED
)
2841 if (LOCAL_SYMBOL_CHECK (s
))
2843 return (s
->bsym
->flags
& BSF_SECTION_SYM
) != 0;
2846 /* Return whether a symbol is equated to another symbol. */
2849 symbol_equated_p (symbolS
*s
)
2851 if (LOCAL_SYMBOL_CHECK (s
))
2853 return s
->sy_value
.X_op
== O_symbol
;
2856 /* Return whether a symbol is equated to another symbol, and should be
2857 treated specially when writing out relocs. */
2860 symbol_equated_reloc_p (symbolS
*s
)
2862 if (LOCAL_SYMBOL_CHECK (s
))
2864 /* X_op_symbol, normally not used for O_symbol, is set by
2865 resolve_symbol_value to flag expression syms that have been
2867 return (s
->sy_value
.X_op
== O_symbol
2868 #if defined (OBJ_COFF) && defined (TE_PE)
2871 && ((s
->sy_flags
.sy_resolved
&& s
->sy_value
.X_op_symbol
!= NULL
)
2872 || ! S_IS_DEFINED (s
)
2873 || S_IS_COMMON (s
)));
2876 /* Return whether a symbol has a constant value. */
2879 symbol_constant_p (symbolS
*s
)
2881 if (LOCAL_SYMBOL_CHECK (s
))
2883 return s
->sy_value
.X_op
== O_constant
;
2886 /* Return whether a symbol was cloned and thus removed from the global
2890 symbol_shadow_p (symbolS
*s
)
2892 if (LOCAL_SYMBOL_CHECK (s
))
2894 return s
->sy_next
== s
;
2897 /* If S was created as a struct symbol, return S, otherwise if S is a
2898 converted local_symbol return the converted symbol, otherwise
2902 symbol_symbolS (symbolS
*s
)
2904 if (LOCAL_SYMBOL_CHECK (s
))
2909 /* Return the BFD symbol for a symbol. */
2912 symbol_get_bfdsym (symbolS
*s
)
2914 if (LOCAL_SYMBOL_CHECK (s
))
2915 s
= local_symbol_convert ((struct local_symbol
*) s
);
2919 /* Set the BFD symbol for a symbol. */
2922 symbol_set_bfdsym (symbolS
*s
, asymbol
*bsym
)
2924 if (LOCAL_SYMBOL_CHECK (s
))
2925 s
= local_symbol_convert ((struct local_symbol
*) s
);
2926 /* Usually, it is harmless to reset a symbol to a BFD section
2927 symbol. For example, obj_elf_change_section sets the BFD symbol
2928 of an old symbol with the newly created section symbol. But when
2929 we have multiple sections with the same name, the newly created
2930 section may have the same name as an old section. We check if the
2931 old symbol has been already marked as a section symbol before
2933 if ((s
->bsym
->flags
& BSF_SECTION_SYM
) == 0)
2935 /* else XXX - What do we do now ? */
2938 #ifdef OBJ_SYMFIELD_TYPE
2940 /* Get a pointer to the object format information for a symbol. */
2943 symbol_get_obj (symbolS
*s
)
2945 if (LOCAL_SYMBOL_CHECK (s
))
2946 s
= local_symbol_convert ((struct local_symbol
*) s
);
2950 /* Set the object format information for a symbol. */
2953 symbol_set_obj (symbolS
*s
, OBJ_SYMFIELD_TYPE
*o
)
2955 if (LOCAL_SYMBOL_CHECK (s
))
2956 s
= local_symbol_convert ((struct local_symbol
*) s
);
2960 #endif /* OBJ_SYMFIELD_TYPE */
2962 #ifdef TC_SYMFIELD_TYPE
2964 /* Get a pointer to the processor information for a symbol. */
2967 symbol_get_tc (symbolS
*s
)
2969 if (LOCAL_SYMBOL_CHECK (s
))
2970 s
= local_symbol_convert ((struct local_symbol
*) s
);
2974 /* Set the processor information for a symbol. */
2977 symbol_set_tc (symbolS
*s
, TC_SYMFIELD_TYPE
*o
)
2979 if (LOCAL_SYMBOL_CHECK (s
))
2980 s
= local_symbol_convert ((struct local_symbol
*) s
);
2984 #endif /* TC_SYMFIELD_TYPE */
2989 symbol_lastP
= NULL
;
2990 symbol_rootP
= NULL
; /* In case we have 0 symbols (!!) */
2991 sy_hash
= hash_new ();
2992 local_hash
= hash_new ();
2994 memset ((char *) (&abs_symbol
), '\0', sizeof (abs_symbol
));
2995 #if defined (EMIT_SECTION_SYMBOLS) || !defined (RELOC_REQUIRES_SYMBOL)
2996 abs_symbol
.bsym
= bfd_abs_section_ptr
->symbol
;
2998 abs_symbol
.sy_value
.X_op
= O_constant
;
2999 abs_symbol
.sy_frag
= &zero_address_frag
;
3001 if (LOCAL_LABELS_FB
)
3006 dot_symbol_init (void)
3008 dot_symbol
.bsym
= bfd_make_empty_symbol (stdoutput
);
3009 if (dot_symbol
.bsym
== NULL
)
3010 as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));
3011 dot_symbol
.bsym
->name
= ".";
3012 dot_symbol
.sy_flags
.sy_forward_ref
= 1;
3013 dot_symbol
.sy_value
.X_op
= O_constant
;
3018 /* Maximum indent level.
3019 Available for modification inside a gdb session. */
3020 static int max_indent_level
= 8;
3023 print_symbol_value_1 (FILE *file
, symbolS
*sym
)
3025 const char *name
= S_GET_NAME (sym
);
3026 if (!name
|| !name
[0])
3028 fprintf (file
, "sym ");
3029 fprintf_vma (file
, (bfd_vma
) ((bfd_hostptr_t
) sym
));
3030 fprintf (file
, " %s", name
);
3032 if (LOCAL_SYMBOL_CHECK (sym
))
3034 struct local_symbol
*locsym
= (struct local_symbol
*) sym
;
3036 if (local_symbol_get_frag (locsym
) != & zero_address_frag
3037 && local_symbol_get_frag (locsym
) != NULL
)
3039 fprintf (file
, " frag ");
3040 fprintf_vma (file
, (bfd_vma
) ((bfd_hostptr_t
) local_symbol_get_frag (locsym
)));
3042 if (local_symbol_resolved_p (locsym
))
3043 fprintf (file
, " resolved");
3044 fprintf (file
, " local");
3048 if (sym
->sy_frag
!= &zero_address_frag
)
3050 fprintf (file
, " frag ");
3051 fprintf_vma (file
, (bfd_vma
) ((bfd_hostptr_t
) sym
->sy_frag
));
3053 if (sym
->sy_flags
.sy_written
)
3054 fprintf (file
, " written");
3055 if (sym
->sy_flags
.sy_resolved
)
3056 fprintf (file
, " resolved");
3057 else if (sym
->sy_flags
.sy_resolving
)
3058 fprintf (file
, " resolving");
3059 if (sym
->sy_flags
.sy_used_in_reloc
)
3060 fprintf (file
, " used-in-reloc");
3061 if (sym
->sy_flags
.sy_used
)
3062 fprintf (file
, " used");
3063 if (S_IS_LOCAL (sym
))
3064 fprintf (file
, " local");
3065 if (S_IS_EXTERNAL (sym
))
3066 fprintf (file
, " extern");
3067 if (S_IS_WEAK (sym
))
3068 fprintf (file
, " weak");
3069 if (S_IS_DEBUG (sym
))
3070 fprintf (file
, " debug");
3071 if (S_IS_DEFINED (sym
))
3072 fprintf (file
, " defined");
3074 if (S_IS_WEAKREFR (sym
))
3075 fprintf (file
, " weakrefr");
3076 if (S_IS_WEAKREFD (sym
))
3077 fprintf (file
, " weakrefd");
3078 fprintf (file
, " %s", segment_name (S_GET_SEGMENT (sym
)));
3079 if (symbol_resolved_p (sym
))
3081 segT s
= S_GET_SEGMENT (sym
);
3083 if (s
!= undefined_section
3084 && s
!= expr_section
)
3085 fprintf (file
, " %lx", (unsigned long) S_GET_VALUE (sym
));
3087 else if (indent_level
< max_indent_level
3088 && S_GET_SEGMENT (sym
) != undefined_section
)
3091 fprintf (file
, "\n%*s<", indent_level
* 4, "");
3092 if (LOCAL_SYMBOL_CHECK (sym
))
3093 fprintf (file
, "constant %lx",
3094 (unsigned long) ((struct local_symbol
*) sym
)->lsy_value
);
3096 print_expr_1 (file
, &sym
->sy_value
);
3097 fprintf (file
, ">");
3104 print_symbol_value (symbolS
*sym
)
3107 print_symbol_value_1 (stderr
, sym
);
3108 fprintf (stderr
, "\n");
3112 print_binary (FILE *file
, const char *name
, expressionS
*exp
)
3115 fprintf (file
, "%s\n%*s<", name
, indent_level
* 4, "");
3116 print_symbol_value_1 (file
, exp
->X_add_symbol
);
3117 fprintf (file
, ">\n%*s<", indent_level
* 4, "");
3118 print_symbol_value_1 (file
, exp
->X_op_symbol
);
3119 fprintf (file
, ">");
3124 print_expr_1 (FILE *file
, expressionS
*exp
)
3126 fprintf (file
, "expr ");
3127 fprintf_vma (file
, (bfd_vma
) ((bfd_hostptr_t
) exp
));
3128 fprintf (file
, " ");
3132 fprintf (file
, "illegal");
3135 fprintf (file
, "absent");
3138 fprintf (file
, "constant %lx", (unsigned long) exp
->X_add_number
);
3142 fprintf (file
, "symbol\n%*s<", indent_level
* 4, "");
3143 print_symbol_value_1 (file
, exp
->X_add_symbol
);
3144 fprintf (file
, ">");
3146 if (exp
->X_add_number
)
3147 fprintf (file
, "\n%*s%lx", indent_level
* 4, "",
3148 (unsigned long) exp
->X_add_number
);
3152 fprintf (file
, "register #%d", (int) exp
->X_add_number
);
3155 fprintf (file
, "big");
3158 fprintf (file
, "uminus -<");
3160 print_symbol_value_1 (file
, exp
->X_add_symbol
);
3161 fprintf (file
, ">");
3162 goto maybe_print_addnum
;
3164 fprintf (file
, "bit_not");
3167 print_binary (file
, "multiply", exp
);
3170 print_binary (file
, "divide", exp
);
3173 print_binary (file
, "modulus", exp
);
3176 print_binary (file
, "lshift", exp
);
3179 print_binary (file
, "rshift", exp
);
3181 case O_bit_inclusive_or
:
3182 print_binary (file
, "bit_ior", exp
);
3184 case O_bit_exclusive_or
:
3185 print_binary (file
, "bit_xor", exp
);
3188 print_binary (file
, "bit_and", exp
);
3191 print_binary (file
, "eq", exp
);
3194 print_binary (file
, "ne", exp
);
3197 print_binary (file
, "lt", exp
);
3200 print_binary (file
, "le", exp
);
3203 print_binary (file
, "ge", exp
);
3206 print_binary (file
, "gt", exp
);
3209 print_binary (file
, "logical_and", exp
);
3212 print_binary (file
, "logical_or", exp
);
3216 fprintf (file
, "add\n%*s<", indent_level
* 4, "");
3217 print_symbol_value_1 (file
, exp
->X_add_symbol
);
3218 fprintf (file
, ">\n%*s<", indent_level
* 4, "");
3219 print_symbol_value_1 (file
, exp
->X_op_symbol
);
3220 fprintf (file
, ">");
3221 goto maybe_print_addnum
;
3224 fprintf (file
, "subtract\n%*s<", indent_level
* 4, "");
3225 print_symbol_value_1 (file
, exp
->X_add_symbol
);
3226 fprintf (file
, ">\n%*s<", indent_level
* 4, "");
3227 print_symbol_value_1 (file
, exp
->X_op_symbol
);
3228 fprintf (file
, ">");
3229 goto maybe_print_addnum
;
3231 fprintf (file
, "{unknown opcode %d}", (int) exp
->X_op
);
3238 print_expr (expressionS
*exp
)
3240 print_expr_1 (stderr
, exp
);
3241 fprintf (stderr
, "\n");
3245 symbol_print_statistics (FILE *file
)
3247 hash_print_statistics (file
, "symbol table", sy_hash
);
3248 hash_print_statistics (file
, "mini local symbol table", local_hash
);
3249 fprintf (file
, "%lu mini local symbols created, %lu converted\n",
3250 local_symbol_count
, local_symbol_conversion_count
);
3253 #ifdef OBJ_COMPLEX_RELC
3255 /* Convert given symbol to a new complex-relocation symbol name. This
3256 may be a recursive function, since it might be called for non-leaf
3257 nodes (plain symbols) in the expression tree. The caller owns the
3258 returning string, so should free it eventually. Errors are
3259 indicated via as_bad and a NULL return value. The given symbol
3260 is marked with sy_used_in_reloc. */
3263 symbol_relc_make_sym (symbolS
* sym
)
3265 char * terminal
= NULL
;
3270 gas_assert (sym
!= NULL
);
3272 /* Recurse to symbol_relc_make_expr if this symbol
3273 is defined as an expression or a plain value. */
3274 if ( S_GET_SEGMENT (sym
) == expr_section
3275 || S_GET_SEGMENT (sym
) == absolute_section
)
3276 return symbol_relc_make_expr (symbol_get_value_expression (sym
));
3278 /* This may be a "fake symbol", referring to ".".
3279 Write out a special null symbol to refer to this position. */
3280 if (! strcmp (S_GET_NAME (sym
), FAKE_LABEL_NAME
))
3281 return xstrdup (".");
3283 /* We hope this is a plain leaf symbol. Construct the encoding
3284 as {S,s}II...:CCCCCCC....
3285 where 'S'/'s' means section symbol / plain symbol
3286 III is decimal for the symbol name length
3287 CCC is the symbol name itself. */
3288 symbol_mark_used_in_reloc (sym
);
3290 sname
= S_GET_NAME (sym
);
3291 sname_len
= strlen (sname
);
3292 typetag
= symbol_section_p (sym
) ? 'S' : 's';
3294 terminal
= XNEWVEC (char, (1 /* S or s */
3295 + 8 /* sname_len in decimal */
3297 + sname_len
/* name itself */
3300 sprintf (terminal
, "%c%d:%s", typetag
, sname_len
, sname
);
3304 /* Convert given value to a new complex-relocation symbol name. This
3305 is a non-recursive function, since it is be called for leaf nodes
3306 (plain values) in the expression tree. The caller owns the
3307 returning string, so should free() it eventually. No errors. */
3310 symbol_relc_make_value (offsetT val
)
3312 char * terminal
= XNEWVEC (char, 28); /* Enough for long long. */
3315 bfd_sprintf_vma (stdoutput
, terminal
+ 1, val
);
3319 /* Convert given expression to a new complex-relocation symbol name.
3320 This is a recursive function, since it traverses the entire given
3321 expression tree. The caller owns the returning string, so should
3322 free() it eventually. Errors are indicated via as_bad() and a NULL
3326 symbol_relc_make_expr (expressionS
* exp
)
3328 const char * opstr
= NULL
; /* Operator prefix string. */
3329 int arity
= 0; /* Arity of this operator. */
3330 char * operands
[3]; /* Up to three operands. */
3331 char * concat_string
= NULL
;
3333 operands
[0] = operands
[1] = operands
[2] = NULL
;
3335 gas_assert (exp
!= NULL
);
3337 /* Match known operators -> fill in opstr, arity, operands[] and fall
3338 through to construct subexpression fragments; may instead return
3339 string directly for leaf nodes. */
3341 /* See expr.h for the meaning of all these enums. Many operators
3342 have an unnatural arity (X_add_number implicitly added). The
3343 conversion logic expands them to explicit "+" subexpressions. */
3348 as_bad ("Unknown expression operator (enum %d)", exp
->X_op
);
3353 return symbol_relc_make_value (exp
->X_add_number
);
3356 if (exp
->X_add_number
)
3360 operands
[0] = symbol_relc_make_sym (exp
->X_add_symbol
);
3361 operands
[1] = symbol_relc_make_value (exp
->X_add_number
);
3365 return symbol_relc_make_sym (exp
->X_add_symbol
);
3367 /* Helper macros for nesting nodes. */
3369 #define HANDLE_XADD_OPT1(str_) \
3370 if (exp->X_add_number) \
3373 opstr = "+:" str_; \
3374 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3375 operands[1] = symbol_relc_make_value (exp->X_add_number); \
3382 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3386 #define HANDLE_XADD_OPT2(str_) \
3387 if (exp->X_add_number) \
3390 opstr = "+:" str_; \
3391 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3392 operands[1] = symbol_relc_make_sym (exp->X_op_symbol); \
3393 operands[2] = symbol_relc_make_value (exp->X_add_number); \
3399 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3400 operands[1] = symbol_relc_make_sym (exp->X_op_symbol); \
3404 /* Nesting nodes. */
3406 case O_uminus
: HANDLE_XADD_OPT1 ("0-");
3407 case O_bit_not
: HANDLE_XADD_OPT1 ("~");
3408 case O_logical_not
: HANDLE_XADD_OPT1 ("!");
3409 case O_multiply
: HANDLE_XADD_OPT2 ("*");
3410 case O_divide
: HANDLE_XADD_OPT2 ("/");
3411 case O_modulus
: HANDLE_XADD_OPT2 ("%");
3412 case O_left_shift
: HANDLE_XADD_OPT2 ("<<");
3413 case O_right_shift
: HANDLE_XADD_OPT2 (">>");
3414 case O_bit_inclusive_or
: HANDLE_XADD_OPT2 ("|");
3415 case O_bit_exclusive_or
: HANDLE_XADD_OPT2 ("^");
3416 case O_bit_and
: HANDLE_XADD_OPT2 ("&");
3417 case O_add
: HANDLE_XADD_OPT2 ("+");
3418 case O_subtract
: HANDLE_XADD_OPT2 ("-");
3419 case O_eq
: HANDLE_XADD_OPT2 ("==");
3420 case O_ne
: HANDLE_XADD_OPT2 ("!=");
3421 case O_lt
: HANDLE_XADD_OPT2 ("<");
3422 case O_le
: HANDLE_XADD_OPT2 ("<=");
3423 case O_ge
: HANDLE_XADD_OPT2 (">=");
3424 case O_gt
: HANDLE_XADD_OPT2 (">");
3425 case O_logical_and
: HANDLE_XADD_OPT2 ("&&");
3426 case O_logical_or
: HANDLE_XADD_OPT2 ("||");
3429 /* Validate & reject early. */
3430 if (arity
>= 1 && ((operands
[0] == NULL
) || (strlen (operands
[0]) == 0)))
3432 if (arity
>= 2 && ((operands
[1] == NULL
) || (strlen (operands
[1]) == 0)))
3434 if (arity
>= 3 && ((operands
[2] == NULL
) || (strlen (operands
[2]) == 0)))
3438 concat_string
= NULL
;
3439 else if (arity
== 0)
3440 concat_string
= xstrdup (opstr
);
3441 else if (arity
== 1)
3442 concat_string
= concat (opstr
, ":", operands
[0], (char *) NULL
);
3443 else if (arity
== 2)
3444 concat_string
= concat (opstr
, ":", operands
[0], ":", operands
[1],
3447 concat_string
= concat (opstr
, ":", operands
[0], ":", operands
[1], ":",
3448 operands
[2], (char *) NULL
);
3450 /* Free operand strings (not opstr). */
3451 if (arity
>= 1) xfree (operands
[0]);
3452 if (arity
>= 2) xfree (operands
[1]);
3453 if (arity
>= 3) xfree (operands
[2]);
3455 return concat_string
;