daily update
[binutils/dougsmingw.git] / gas / symbols.c
blob9202a9b315ab0dcf921a3af8040aa90ac476d997
1 /* symbols.c -symbol table-
2 Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
6 This file is part of GAS, the GNU Assembler.
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
11 any later version.
13 GAS is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
21 02110-1301, USA. */
23 /* #define DEBUG_SYMS / * to debug symbol list maintenance. */
25 #include "as.h"
27 #include "safe-ctype.h"
28 #include "obstack.h" /* For "symbols.h" */
29 #include "subsegs.h"
31 #include "struc-symbol.h"
33 /* This is non-zero if symbols are case sensitive, which is the
34 default. */
35 int symbols_case_sensitive = 1;
37 #ifndef WORKING_DOT_WORD
38 extern int new_broken_words;
39 #endif
41 /* symbol-name => struct symbol pointer */
42 static struct hash_control *sy_hash;
44 /* Table of local symbols. */
45 static struct hash_control *local_hash;
47 /* Below are commented in "symbols.h". */
48 symbolS *symbol_rootP;
49 symbolS *symbol_lastP;
50 symbolS abs_symbol;
52 #ifdef DEBUG_SYMS
53 #define debug_verify_symchain verify_symbol_chain
54 #else
55 #define debug_verify_symchain(root, last) ((void) 0)
56 #endif
58 #define DOLLAR_LABEL_CHAR '\001'
59 #define LOCAL_LABEL_CHAR '\002'
61 struct obstack notes;
62 #ifdef TE_PE
63 /* The name of an external symbol which is
64 used to make weak PE symbol names unique. */
65 const char * an_external_name;
66 #endif
68 static char *save_symbol_name (const char *);
69 static void fb_label_init (void);
70 static long dollar_label_instance (long);
71 static long fb_label_instance (long);
73 static void print_binary (FILE *, const char *, expressionS *);
74 static void report_op_error (symbolS *, symbolS *, symbolS *);
76 /* Return a pointer to a new symbol. Die if we can't make a new
77 symbol. Fill in the symbol's values. Add symbol to end of symbol
78 chain.
80 This function should be called in the general case of creating a
81 symbol. However, if the output file symbol table has already been
82 set, and you are certain that this symbol won't be wanted in the
83 output file, you can call symbol_create. */
85 symbolS *
86 symbol_new (const char *name, segT segment, valueT valu, fragS *frag)
88 symbolS *symbolP = symbol_create (name, segment, valu, frag);
90 /* Link to end of symbol chain. */
92 extern int symbol_table_frozen;
93 if (symbol_table_frozen)
94 abort ();
96 symbol_append (symbolP, symbol_lastP, &symbol_rootP, &symbol_lastP);
98 return symbolP;
101 /* Save a symbol name on a permanent obstack, and convert it according
102 to the object file format. */
104 static char *
105 save_symbol_name (const char *name)
107 unsigned int name_length;
108 char *ret;
110 name_length = strlen (name) + 1; /* +1 for \0. */
111 obstack_grow (&notes, name, name_length);
112 ret = (char *) obstack_finish (&notes);
114 #ifdef tc_canonicalize_symbol_name
115 ret = tc_canonicalize_symbol_name (ret);
116 #endif
118 if (! symbols_case_sensitive)
120 char *s;
122 for (s = ret; *s != '\0'; s++)
123 *s = TOUPPER (*s);
126 return ret;
129 symbolS *
130 symbol_create (const char *name, /* It is copied, the caller can destroy/modify. */
131 segT segment, /* Segment identifier (SEG_<something>). */
132 valueT valu, /* Symbol value. */
133 fragS *frag /* Associated fragment. */)
135 char *preserved_copy_of_name;
136 symbolS *symbolP;
138 preserved_copy_of_name = save_symbol_name (name);
140 symbolP = (symbolS *) obstack_alloc (&notes, sizeof (symbolS));
142 /* symbol must be born in some fixed state. This seems as good as any. */
143 memset (symbolP, 0, sizeof (symbolS));
145 symbolP->bsym = bfd_make_empty_symbol (stdoutput);
146 if (symbolP->bsym == NULL)
147 as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));
148 S_SET_NAME (symbolP, preserved_copy_of_name);
150 S_SET_SEGMENT (symbolP, segment);
151 S_SET_VALUE (symbolP, valu);
152 symbol_clear_list_pointers (symbolP);
154 symbolP->sy_frag = frag;
156 obj_symbol_new_hook (symbolP);
158 #ifdef tc_symbol_new_hook
159 tc_symbol_new_hook (symbolP);
160 #endif
162 return symbolP;
166 /* Local symbol support. If we can get away with it, we keep only a
167 small amount of information for local symbols. */
169 static symbolS *local_symbol_convert (struct local_symbol *);
171 /* Used for statistics. */
173 static unsigned long local_symbol_count;
174 static unsigned long local_symbol_conversion_count;
176 /* This macro is called with a symbol argument passed by reference.
177 It returns whether this is a local symbol. If necessary, it
178 changes its argument to the real symbol. */
180 #define LOCAL_SYMBOL_CHECK(s) \
181 (s->bsym == NULL \
182 ? (local_symbol_converted_p ((struct local_symbol *) s) \
183 ? (s = local_symbol_get_real_symbol ((struct local_symbol *) s), \
184 0) \
185 : 1) \
186 : 0)
188 /* Create a local symbol and insert it into the local hash table. */
190 static struct local_symbol *
191 local_symbol_make (const char *name, segT section, valueT val, fragS *frag)
193 char *name_copy;
194 struct local_symbol *ret;
196 ++local_symbol_count;
198 name_copy = save_symbol_name (name);
200 ret = (struct local_symbol *) obstack_alloc (&notes, sizeof *ret);
201 ret->lsy_marker = NULL;
202 ret->lsy_name = name_copy;
203 ret->lsy_section = section;
204 local_symbol_set_frag (ret, frag);
205 ret->lsy_value = val;
207 hash_jam (local_hash, name_copy, (void *) ret);
209 return ret;
212 /* Convert a local symbol into a real symbol. Note that we do not
213 reclaim the space used by the local symbol. */
215 static symbolS *
216 local_symbol_convert (struct local_symbol *locsym)
218 symbolS *ret;
220 gas_assert (locsym->lsy_marker == NULL);
221 if (local_symbol_converted_p (locsym))
222 return local_symbol_get_real_symbol (locsym);
224 ++local_symbol_conversion_count;
226 ret = symbol_new (locsym->lsy_name, locsym->lsy_section, locsym->lsy_value,
227 local_symbol_get_frag (locsym));
229 if (local_symbol_resolved_p (locsym))
230 ret->sy_resolved = 1;
232 /* Local symbols are always either defined or used. */
233 ret->sy_used = 1;
235 #ifdef TC_LOCAL_SYMFIELD_CONVERT
236 TC_LOCAL_SYMFIELD_CONVERT (locsym, ret);
237 #endif
239 symbol_table_insert (ret);
241 local_symbol_mark_converted (locsym);
242 local_symbol_set_real_symbol (locsym, ret);
244 hash_jam (local_hash, locsym->lsy_name, NULL);
246 return ret;
249 static void
250 define_sym_at_dot (symbolS *symbolP)
252 symbolP->sy_frag = frag_now;
253 #ifdef OBJ_VMS
254 S_SET_OTHER (symbolP, const_flag);
255 #endif
256 S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
257 S_SET_SEGMENT (symbolP, now_seg);
260 /* We have just seen "<name>:".
261 Creates a struct symbol unless it already exists.
263 Gripes if we are redefining a symbol incompatibly (and ignores it). */
265 symbolS *
266 colon (/* Just seen "x:" - rattle symbols & frags. */
267 const char *sym_name /* Symbol name, as a cannonical string. */
268 /* We copy this string: OK to alter later. */)
270 register symbolS *symbolP; /* Symbol we are working with. */
272 /* Sun local labels go out of scope whenever a non-local symbol is
273 defined. */
274 if (LOCAL_LABELS_DOLLAR
275 && !bfd_is_local_label_name (stdoutput, sym_name))
276 dollar_label_clear ();
278 #ifndef WORKING_DOT_WORD
279 if (new_broken_words)
281 struct broken_word *a;
282 int possible_bytes;
283 fragS *frag_tmp;
284 char *frag_opcode;
286 if (now_seg == absolute_section)
288 as_bad (_("cannot define symbol `%s' in absolute section"), sym_name);
289 return NULL;
292 possible_bytes = (md_short_jump_size
293 + new_broken_words * md_long_jump_size);
295 frag_tmp = frag_now;
296 frag_opcode = frag_var (rs_broken_word,
297 possible_bytes,
298 possible_bytes,
299 (relax_substateT) 0,
300 (symbolS *) broken_words,
301 (offsetT) 0,
302 NULL);
304 /* We want to store the pointer to where to insert the jump
305 table in the fr_opcode of the rs_broken_word frag. This
306 requires a little hackery. */
307 while (frag_tmp
308 && (frag_tmp->fr_type != rs_broken_word
309 || frag_tmp->fr_opcode))
310 frag_tmp = frag_tmp->fr_next;
311 know (frag_tmp);
312 frag_tmp->fr_opcode = frag_opcode;
313 new_broken_words = 0;
315 for (a = broken_words; a && a->dispfrag == 0; a = a->next_broken_word)
316 a->dispfrag = frag_tmp;
318 #endif /* WORKING_DOT_WORD */
320 if ((symbolP = symbol_find (sym_name)) != 0)
322 S_CLEAR_WEAKREFR (symbolP);
323 #ifdef RESOLVE_SYMBOL_REDEFINITION
324 if (RESOLVE_SYMBOL_REDEFINITION (symbolP))
325 return symbolP;
326 #endif
327 /* Now check for undefined symbols. */
328 if (LOCAL_SYMBOL_CHECK (symbolP))
330 struct local_symbol *locsym = (struct local_symbol *) symbolP;
332 if (locsym->lsy_section != undefined_section
333 && (local_symbol_get_frag (locsym) != frag_now
334 || locsym->lsy_section != now_seg
335 || locsym->lsy_value != frag_now_fix ()))
337 as_bad (_("symbol `%s' is already defined"), sym_name);
338 return symbolP;
341 locsym->lsy_section = now_seg;
342 local_symbol_set_frag (locsym, frag_now);
343 locsym->lsy_value = frag_now_fix ();
345 else if (!(S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
346 || S_IS_COMMON (symbolP)
347 || S_IS_VOLATILE (symbolP))
349 if (S_IS_VOLATILE (symbolP))
351 symbolP = symbol_clone (symbolP, 1);
352 S_SET_VALUE (symbolP, 0);
353 S_CLEAR_VOLATILE (symbolP);
355 if (S_GET_VALUE (symbolP) == 0)
357 define_sym_at_dot (symbolP);
358 #ifdef N_UNDF
359 know (N_UNDF == 0);
360 #endif /* if we have one, it better be zero. */
363 else
365 /* There are still several cases to check:
367 A .comm/.lcomm symbol being redefined as initialized
368 data is OK
370 A .comm/.lcomm symbol being redefined with a larger
371 size is also OK
373 This only used to be allowed on VMS gas, but Sun cc
374 on the sparc also depends on it. */
376 if (((!S_IS_DEBUG (symbolP)
377 && (!S_IS_DEFINED (symbolP) || S_IS_COMMON (symbolP))
378 && S_IS_EXTERNAL (symbolP))
379 || S_GET_SEGMENT (symbolP) == bss_section)
380 && (now_seg == data_section
381 || now_seg == bss_section
382 || now_seg == S_GET_SEGMENT (symbolP)))
384 /* Select which of the 2 cases this is. */
385 if (now_seg != data_section)
387 /* New .comm for prev .comm symbol.
389 If the new size is larger we just change its
390 value. If the new size is smaller, we ignore
391 this symbol. */
392 if (S_GET_VALUE (symbolP)
393 < ((unsigned) frag_now_fix ()))
395 S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
398 else
400 /* It is a .comm/.lcomm being converted to initialized
401 data. */
402 define_sym_at_dot (symbolP);
405 else
407 #if (!defined (OBJ_AOUT) && !defined (OBJ_MAYBE_AOUT) \
408 && !defined (OBJ_BOUT) && !defined (OBJ_MAYBE_BOUT))
409 static const char *od_buf = "";
410 #else
411 char od_buf[100];
412 od_buf[0] = '\0';
413 if (OUTPUT_FLAVOR == bfd_target_aout_flavour)
414 sprintf (od_buf, "%d.%d.",
415 S_GET_OTHER (symbolP),
416 S_GET_DESC (symbolP));
417 #endif
418 as_bad (_("symbol `%s' is already defined as \"%s\"/%s%ld"),
419 sym_name,
420 segment_name (S_GET_SEGMENT (symbolP)),
421 od_buf,
422 (long) S_GET_VALUE (symbolP));
424 } /* if the undefined symbol has no value */
426 else
428 /* Don't blow up if the definition is the same. */
429 if (!(frag_now == symbolP->sy_frag
430 && S_GET_VALUE (symbolP) == frag_now_fix ()
431 && S_GET_SEGMENT (symbolP) == now_seg))
433 as_bad (_("symbol `%s' is already defined"), sym_name);
434 symbolP = symbol_clone (symbolP, 0);
435 define_sym_at_dot (symbolP);
440 else if (! flag_keep_locals && bfd_is_local_label_name (stdoutput, sym_name))
442 symbolP = (symbolS *) local_symbol_make (sym_name, now_seg,
443 (valueT) frag_now_fix (),
444 frag_now);
446 else
448 symbolP = symbol_new (sym_name, now_seg, (valueT) frag_now_fix (),
449 frag_now);
450 #ifdef OBJ_VMS
451 S_SET_OTHER (symbolP, const_flag);
452 #endif /* OBJ_VMS */
454 symbol_table_insert (symbolP);
457 if (mri_common_symbol != NULL)
459 /* This symbol is actually being defined within an MRI common
460 section. This requires special handling. */
461 if (LOCAL_SYMBOL_CHECK (symbolP))
462 symbolP = local_symbol_convert ((struct local_symbol *) symbolP);
463 symbolP->sy_value.X_op = O_symbol;
464 symbolP->sy_value.X_add_symbol = mri_common_symbol;
465 symbolP->sy_value.X_add_number = S_GET_VALUE (mri_common_symbol);
466 symbolP->sy_frag = &zero_address_frag;
467 S_SET_SEGMENT (symbolP, expr_section);
468 symbolP->sy_mri_common = 1;
471 #ifdef tc_frob_label
472 tc_frob_label (symbolP);
473 #endif
474 #ifdef obj_frob_label
475 obj_frob_label (symbolP);
476 #endif
478 return symbolP;
481 /* Die if we can't insert the symbol. */
483 void
484 symbol_table_insert (symbolS *symbolP)
486 register const char *error_string;
488 know (symbolP);
489 know (S_GET_NAME (symbolP));
491 if (LOCAL_SYMBOL_CHECK (symbolP))
493 error_string = hash_jam (local_hash, S_GET_NAME (symbolP),
494 (void *) symbolP);
495 if (error_string != NULL)
496 as_fatal (_("inserting \"%s\" into symbol table failed: %s"),
497 S_GET_NAME (symbolP), error_string);
498 return;
501 if ((error_string = hash_jam (sy_hash, S_GET_NAME (symbolP), (void *) symbolP)))
503 as_fatal (_("inserting \"%s\" into symbol table failed: %s"),
504 S_GET_NAME (symbolP), error_string);
505 } /* on error */
508 /* If a symbol name does not exist, create it as undefined, and insert
509 it into the symbol table. Return a pointer to it. */
511 symbolS *
512 symbol_find_or_make (const char *name)
514 register symbolS *symbolP;
516 symbolP = symbol_find (name);
518 if (symbolP == NULL)
520 if (! flag_keep_locals && bfd_is_local_label_name (stdoutput, name))
522 symbolP = md_undefined_symbol ((char *) name);
523 if (symbolP != NULL)
524 return symbolP;
526 symbolP = (symbolS *) local_symbol_make (name, undefined_section,
527 (valueT) 0,
528 &zero_address_frag);
529 return symbolP;
532 symbolP = symbol_make (name);
534 symbol_table_insert (symbolP);
535 } /* if symbol wasn't found */
537 return (symbolP);
540 symbolS *
541 symbol_make (const char *name)
543 symbolS *symbolP;
545 /* Let the machine description default it, e.g. for register names. */
546 symbolP = md_undefined_symbol ((char *) name);
548 if (!symbolP)
549 symbolP = symbol_new (name, undefined_section, (valueT) 0, &zero_address_frag);
551 return (symbolP);
554 symbolS *
555 symbol_clone (symbolS *orgsymP, int replace)
557 symbolS *newsymP;
558 asymbol *bsymorg, *bsymnew;
560 /* Running local_symbol_convert on a clone that's not the one currently
561 in local_hash would incorrectly replace the hash entry. Thus the
562 symbol must be converted here. Note that the rest of the function
563 depends on not encountering an unconverted symbol. */
564 if (LOCAL_SYMBOL_CHECK (orgsymP))
565 orgsymP = local_symbol_convert ((struct local_symbol *) orgsymP);
566 bsymorg = orgsymP->bsym;
568 newsymP = (symbolS *) obstack_alloc (&notes, sizeof (*newsymP));
569 *newsymP = *orgsymP;
570 bsymnew = bfd_make_empty_symbol (bfd_asymbol_bfd (bsymorg));
571 if (bsymnew == NULL)
572 as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));
573 newsymP->bsym = bsymnew;
574 bsymnew->name = bsymorg->name;
575 bsymnew->flags = bsymorg->flags;
576 bsymnew->section = bsymorg->section;
577 bfd_copy_private_symbol_data (bfd_asymbol_bfd (bsymorg), bsymorg,
578 bfd_asymbol_bfd (bsymnew), bsymnew);
580 #ifdef obj_symbol_clone_hook
581 obj_symbol_clone_hook (newsymP, orgsymP);
582 #endif
584 #ifdef tc_symbol_clone_hook
585 tc_symbol_clone_hook (newsymP, orgsymP);
586 #endif
588 if (replace)
590 if (symbol_rootP == orgsymP)
591 symbol_rootP = newsymP;
592 else if (orgsymP->sy_previous)
594 orgsymP->sy_previous->sy_next = newsymP;
595 orgsymP->sy_previous = NULL;
597 if (symbol_lastP == orgsymP)
598 symbol_lastP = newsymP;
599 else if (orgsymP->sy_next)
600 orgsymP->sy_next->sy_previous = newsymP;
602 /* Symbols that won't be output can't be external. */
603 S_CLEAR_EXTERNAL (orgsymP);
604 orgsymP->sy_previous = orgsymP->sy_next = orgsymP;
605 debug_verify_symchain (symbol_rootP, symbol_lastP);
607 symbol_table_insert (newsymP);
609 else
611 /* Symbols that won't be output can't be external. */
612 S_CLEAR_EXTERNAL (newsymP);
613 newsymP->sy_previous = newsymP->sy_next = newsymP;
616 return newsymP;
619 /* Referenced symbols, if they are forward references, need to be cloned
620 (without replacing the original) so that the value of the referenced
621 symbols at the point of use . */
623 #undef symbol_clone_if_forward_ref
624 symbolS *
625 symbol_clone_if_forward_ref (symbolS *symbolP, int is_forward)
627 if (symbolP && !LOCAL_SYMBOL_CHECK (symbolP))
629 symbolS *add_symbol = symbolP->sy_value.X_add_symbol;
630 symbolS *op_symbol = symbolP->sy_value.X_op_symbol;
632 if (symbolP->sy_forward_ref)
633 is_forward = 1;
635 if (is_forward)
637 /* assign_symbol() clones volatile symbols; pre-existing expressions
638 hold references to the original instance, but want the current
639 value. Just repeat the lookup. */
640 if (add_symbol && S_IS_VOLATILE (add_symbol))
641 add_symbol = symbol_find_exact (S_GET_NAME (add_symbol));
642 if (op_symbol && S_IS_VOLATILE (op_symbol))
643 op_symbol = symbol_find_exact (S_GET_NAME (op_symbol));
646 /* Re-using sy_resolving here, as this routine cannot get called from
647 symbol resolution code. */
648 if (symbolP->bsym->section == expr_section && !symbolP->sy_resolving)
650 symbolP->sy_resolving = 1;
651 add_symbol = symbol_clone_if_forward_ref (add_symbol, is_forward);
652 op_symbol = symbol_clone_if_forward_ref (op_symbol, is_forward);
653 symbolP->sy_resolving = 0;
656 if (symbolP->sy_forward_ref
657 || add_symbol != symbolP->sy_value.X_add_symbol
658 || op_symbol != symbolP->sy_value.X_op_symbol)
659 symbolP = symbol_clone (symbolP, 0);
661 symbolP->sy_value.X_add_symbol = add_symbol;
662 symbolP->sy_value.X_op_symbol = op_symbol;
665 return symbolP;
668 symbolS *
669 symbol_temp_new (segT seg, valueT ofs, fragS *frag)
671 return symbol_new (FAKE_LABEL_NAME, seg, ofs, frag);
674 symbolS *
675 symbol_temp_new_now (void)
677 return symbol_temp_new (now_seg, frag_now_fix (), frag_now);
680 symbolS *
681 symbol_temp_make (void)
683 return symbol_make (FAKE_LABEL_NAME);
686 /* Implement symbol table lookup.
687 In: A symbol's name as a string: '\0' can't be part of a symbol name.
688 Out: NULL if the name was not in the symbol table, else the address
689 of a struct symbol associated with that name. */
691 symbolS *
692 symbol_find_exact (const char *name)
694 return symbol_find_exact_noref (name, 0);
697 symbolS *
698 symbol_find_exact_noref (const char *name, int noref)
700 struct local_symbol *locsym;
701 symbolS* sym;
703 locsym = (struct local_symbol *) hash_find (local_hash, name);
704 if (locsym != NULL)
705 return (symbolS *) locsym;
707 sym = ((symbolS *) hash_find (sy_hash, name));
709 /* Any references to the symbol, except for the reference in
710 .weakref, must clear this flag, such that the symbol does not
711 turn into a weak symbol. Note that we don't have to handle the
712 local_symbol case, since a weakrefd is always promoted out of the
713 local_symbol table when it is turned into a weak symbol. */
714 if (sym && ! noref)
715 S_CLEAR_WEAKREFD (sym);
717 return sym;
720 symbolS *
721 symbol_find (const char *name)
723 return symbol_find_noref (name, 0);
726 symbolS *
727 symbol_find_noref (const char *name, int noref)
729 #ifdef tc_canonicalize_symbol_name
731 char *copy;
732 size_t len = strlen (name) + 1;
734 copy = (char *) alloca (len);
735 memcpy (copy, name, len);
736 name = tc_canonicalize_symbol_name (copy);
738 #endif
740 if (! symbols_case_sensitive)
742 char *copy;
743 const char *orig;
744 unsigned char c;
746 orig = name;
747 name = copy = (char *) alloca (strlen (name) + 1);
749 while ((c = *orig++) != '\0')
751 *copy++ = TOUPPER (c);
753 *copy = '\0';
756 return symbol_find_exact_noref (name, noref);
759 /* Once upon a time, symbols were kept in a singly linked list. At
760 least coff needs to be able to rearrange them from time to time, for
761 which a doubly linked list is much more convenient. Loic did these
762 as macros which seemed dangerous to me so they're now functions.
763 xoxorich. */
765 /* Link symbol ADDME after symbol TARGET in the chain. */
767 void
768 symbol_append (symbolS *addme, symbolS *target,
769 symbolS **rootPP, symbolS **lastPP)
771 if (LOCAL_SYMBOL_CHECK (addme))
772 abort ();
773 if (target != NULL && LOCAL_SYMBOL_CHECK (target))
774 abort ();
776 if (target == NULL)
778 know (*rootPP == NULL);
779 know (*lastPP == NULL);
780 addme->sy_next = NULL;
781 addme->sy_previous = NULL;
782 *rootPP = addme;
783 *lastPP = addme;
784 return;
785 } /* if the list is empty */
787 if (target->sy_next != NULL)
789 target->sy_next->sy_previous = addme;
791 else
793 know (*lastPP == target);
794 *lastPP = addme;
795 } /* if we have a next */
797 addme->sy_next = target->sy_next;
798 target->sy_next = addme;
799 addme->sy_previous = target;
801 debug_verify_symchain (symbol_rootP, symbol_lastP);
804 /* Set the chain pointers of SYMBOL to null. */
806 void
807 symbol_clear_list_pointers (symbolS *symbolP)
809 if (LOCAL_SYMBOL_CHECK (symbolP))
810 abort ();
811 symbolP->sy_next = NULL;
812 symbolP->sy_previous = NULL;
815 /* Remove SYMBOLP from the list. */
817 void
818 symbol_remove (symbolS *symbolP, symbolS **rootPP, symbolS **lastPP)
820 if (LOCAL_SYMBOL_CHECK (symbolP))
821 abort ();
823 if (symbolP == *rootPP)
825 *rootPP = symbolP->sy_next;
826 } /* if it was the root */
828 if (symbolP == *lastPP)
830 *lastPP = symbolP->sy_previous;
831 } /* if it was the tail */
833 if (symbolP->sy_next != NULL)
835 symbolP->sy_next->sy_previous = symbolP->sy_previous;
836 } /* if not last */
838 if (symbolP->sy_previous != NULL)
840 symbolP->sy_previous->sy_next = symbolP->sy_next;
841 } /* if not first */
843 debug_verify_symchain (*rootPP, *lastPP);
846 /* Link symbol ADDME before symbol TARGET in the chain. */
848 void
849 symbol_insert (symbolS *addme, symbolS *target,
850 symbolS **rootPP, symbolS **lastPP ATTRIBUTE_UNUSED)
852 if (LOCAL_SYMBOL_CHECK (addme))
853 abort ();
854 if (LOCAL_SYMBOL_CHECK (target))
855 abort ();
857 if (target->sy_previous != NULL)
859 target->sy_previous->sy_next = addme;
861 else
863 know (*rootPP == target);
864 *rootPP = addme;
865 } /* if not first */
867 addme->sy_previous = target->sy_previous;
868 target->sy_previous = addme;
869 addme->sy_next = target;
871 debug_verify_symchain (*rootPP, *lastPP);
874 void
875 verify_symbol_chain (symbolS *rootP, symbolS *lastP)
877 symbolS *symbolP = rootP;
879 if (symbolP == NULL)
880 return;
882 for (; symbol_next (symbolP) != NULL; symbolP = symbol_next (symbolP))
884 gas_assert (symbolP->bsym != NULL);
885 gas_assert (symbolP->sy_next->sy_previous == symbolP);
888 gas_assert (lastP == symbolP);
891 #ifdef OBJ_COMPLEX_RELC
893 static int
894 use_complex_relocs_for (symbolS * symp)
896 switch (symp->sy_value.X_op)
898 case O_constant:
899 return 0;
901 case O_symbol:
902 case O_symbol_rva:
903 case O_uminus:
904 case O_bit_not:
905 case O_logical_not:
906 if ( (S_IS_COMMON (symp->sy_value.X_add_symbol)
907 || S_IS_LOCAL (symp->sy_value.X_add_symbol))
909 (S_IS_DEFINED (symp->sy_value.X_add_symbol)
910 && S_GET_SEGMENT (symp->sy_value.X_add_symbol) != expr_section))
911 return 0;
912 break;
914 case O_multiply:
915 case O_divide:
916 case O_modulus:
917 case O_left_shift:
918 case O_right_shift:
919 case O_bit_inclusive_or:
920 case O_bit_or_not:
921 case O_bit_exclusive_or:
922 case O_bit_and:
923 case O_add:
924 case O_subtract:
925 case O_eq:
926 case O_ne:
927 case O_lt:
928 case O_le:
929 case O_ge:
930 case O_gt:
931 case O_logical_and:
932 case O_logical_or:
934 if ( (S_IS_COMMON (symp->sy_value.X_add_symbol)
935 || S_IS_LOCAL (symp->sy_value.X_add_symbol))
937 (S_IS_COMMON (symp->sy_value.X_op_symbol)
938 || S_IS_LOCAL (symp->sy_value.X_op_symbol))
940 && S_IS_DEFINED (symp->sy_value.X_add_symbol)
941 && S_IS_DEFINED (symp->sy_value.X_op_symbol)
942 && S_GET_SEGMENT (symp->sy_value.X_add_symbol) != expr_section
943 && S_GET_SEGMENT (symp->sy_value.X_op_symbol) != expr_section)
944 return 0;
945 break;
947 default:
948 break;
950 return 1;
952 #endif
954 static void
955 report_op_error (symbolS *symp, symbolS *left, symbolS *right)
957 char *file;
958 unsigned int line;
959 segT seg_left = S_GET_SEGMENT (left);
960 segT seg_right = right ? S_GET_SEGMENT (right) : 0;
962 if (expr_symbol_where (symp, &file, &line))
964 if (seg_left == undefined_section)
965 as_bad_where (file, line,
966 _("undefined symbol `%s' in operation"),
967 S_GET_NAME (left));
968 if (seg_right == undefined_section)
969 as_bad_where (file, line,
970 _("undefined symbol `%s' in operation"),
971 S_GET_NAME (right));
972 if (seg_left != undefined_section
973 && seg_right != undefined_section)
975 if (right)
976 as_bad_where (file, line,
977 _("invalid sections for operation on `%s' and `%s'"),
978 S_GET_NAME (left), S_GET_NAME (right));
979 else
980 as_bad_where (file, line,
981 _("invalid section for operation on `%s'"),
982 S_GET_NAME (left));
986 else
988 if (seg_left == undefined_section)
989 as_bad (_("undefined symbol `%s' in operation setting `%s'"),
990 S_GET_NAME (left), S_GET_NAME (symp));
991 if (seg_right == undefined_section)
992 as_bad (_("undefined symbol `%s' in operation setting `%s'"),
993 S_GET_NAME (right), S_GET_NAME (symp));
994 if (seg_left != undefined_section
995 && seg_right != undefined_section)
997 if (right)
998 as_bad (_("invalid sections for operation on `%s' and `%s' setting `%s'"),
999 S_GET_NAME (left), S_GET_NAME (right), S_GET_NAME (symp));
1000 else
1001 as_bad (_("invalid section for operation on `%s' setting `%s'"),
1002 S_GET_NAME (left), S_GET_NAME (symp));
1007 /* Resolve the value of a symbol. This is called during the final
1008 pass over the symbol table to resolve any symbols with complex
1009 values. */
1011 valueT
1012 resolve_symbol_value (symbolS *symp)
1014 int resolved;
1015 valueT final_val = 0;
1016 segT final_seg;
1018 if (LOCAL_SYMBOL_CHECK (symp))
1020 struct local_symbol *locsym = (struct local_symbol *) symp;
1022 final_val = locsym->lsy_value;
1023 if (local_symbol_resolved_p (locsym))
1024 return final_val;
1026 final_val += local_symbol_get_frag (locsym)->fr_address / OCTETS_PER_BYTE;
1028 if (finalize_syms)
1030 locsym->lsy_value = final_val;
1031 local_symbol_mark_resolved (locsym);
1034 return final_val;
1037 if (symp->sy_resolved)
1039 if (symp->sy_value.X_op == O_constant)
1040 return (valueT) symp->sy_value.X_add_number;
1041 else
1042 return 0;
1045 resolved = 0;
1046 final_seg = S_GET_SEGMENT (symp);
1048 if (symp->sy_resolving)
1050 if (finalize_syms)
1051 as_bad (_("symbol definition loop encountered at `%s'"),
1052 S_GET_NAME (symp));
1053 final_val = 0;
1054 resolved = 1;
1056 #ifdef OBJ_COMPLEX_RELC
1057 else if (final_seg == expr_section
1058 && use_complex_relocs_for (symp))
1060 symbolS * relc_symbol = NULL;
1061 char * relc_symbol_name = NULL;
1063 relc_symbol_name = symbol_relc_make_expr (& symp->sy_value);
1065 /* For debugging, print out conversion input & output. */
1066 #ifdef DEBUG_SYMS
1067 print_expr (& symp->sy_value);
1068 if (relc_symbol_name)
1069 fprintf (stderr, "-> relc symbol: %s\n", relc_symbol_name);
1070 #endif
1072 if (relc_symbol_name != NULL)
1073 relc_symbol = symbol_new (relc_symbol_name, undefined_section,
1074 0, & zero_address_frag);
1076 if (relc_symbol == NULL)
1078 as_bad (_("cannot convert expression symbol %s to complex relocation"),
1079 S_GET_NAME (symp));
1080 resolved = 0;
1082 else
1084 symbol_table_insert (relc_symbol);
1086 /* S_CLEAR_EXTERNAL (relc_symbol); */
1087 if (symp->bsym->flags & BSF_SRELC)
1088 relc_symbol->bsym->flags |= BSF_SRELC;
1089 else
1090 relc_symbol->bsym->flags |= BSF_RELC;
1091 /* symp->bsym->flags |= BSF_RELC; */
1092 copy_symbol_attributes (symp, relc_symbol);
1093 symp->sy_value.X_op = O_symbol;
1094 symp->sy_value.X_add_symbol = relc_symbol;
1095 symp->sy_value.X_add_number = 0;
1096 resolved = 1;
1099 final_seg = undefined_section;
1100 goto exit_dont_set_value;
1102 #endif
1103 else
1105 symbolS *add_symbol, *op_symbol;
1106 offsetT left, right;
1107 segT seg_left, seg_right;
1108 operatorT op;
1109 int move_seg_ok;
1111 symp->sy_resolving = 1;
1113 /* Help out with CSE. */
1114 add_symbol = symp->sy_value.X_add_symbol;
1115 op_symbol = symp->sy_value.X_op_symbol;
1116 final_val = symp->sy_value.X_add_number;
1117 op = symp->sy_value.X_op;
1119 switch (op)
1121 default:
1122 BAD_CASE (op);
1123 break;
1125 case O_absent:
1126 final_val = 0;
1127 /* Fall through. */
1129 case O_constant:
1130 final_val += symp->sy_frag->fr_address / OCTETS_PER_BYTE;
1131 if (final_seg == expr_section)
1132 final_seg = absolute_section;
1133 /* Fall through. */
1135 case O_register:
1136 resolved = 1;
1137 break;
1139 case O_symbol:
1140 case O_symbol_rva:
1141 left = resolve_symbol_value (add_symbol);
1142 seg_left = S_GET_SEGMENT (add_symbol);
1143 if (finalize_syms)
1144 symp->sy_value.X_op_symbol = NULL;
1146 do_symbol:
1147 if (S_IS_WEAKREFR (symp))
1149 gas_assert (final_val == 0);
1150 if (S_IS_WEAKREFR (add_symbol))
1152 gas_assert (add_symbol->sy_value.X_op == O_symbol
1153 && add_symbol->sy_value.X_add_number == 0);
1154 add_symbol = add_symbol->sy_value.X_add_symbol;
1155 gas_assert (! S_IS_WEAKREFR (add_symbol));
1156 symp->sy_value.X_add_symbol = add_symbol;
1160 if (symp->sy_mri_common)
1162 /* This is a symbol inside an MRI common section. The
1163 relocation routines are going to handle it specially.
1164 Don't change the value. */
1165 resolved = symbol_resolved_p (add_symbol);
1166 break;
1169 if (finalize_syms && final_val == 0)
1171 if (LOCAL_SYMBOL_CHECK (add_symbol))
1172 add_symbol = local_symbol_convert ((struct local_symbol *)
1173 add_symbol);
1174 copy_symbol_attributes (symp, add_symbol);
1177 /* If we have equated this symbol to an undefined or common
1178 symbol, keep X_op set to O_symbol, and don't change
1179 X_add_number. This permits the routine which writes out
1180 relocation to detect this case, and convert the
1181 relocation to be against the symbol to which this symbol
1182 is equated. */
1183 if (! S_IS_DEFINED (add_symbol)
1184 #if defined (OBJ_COFF) && defined (TE_PE)
1185 || S_IS_WEAK (add_symbol)
1186 #endif
1187 || S_IS_COMMON (add_symbol))
1189 if (finalize_syms)
1191 symp->sy_value.X_op = O_symbol;
1192 symp->sy_value.X_add_symbol = add_symbol;
1193 symp->sy_value.X_add_number = final_val;
1194 /* Use X_op_symbol as a flag. */
1195 symp->sy_value.X_op_symbol = add_symbol;
1196 final_seg = seg_left;
1198 final_val = 0;
1199 resolved = symbol_resolved_p (add_symbol);
1200 symp->sy_resolving = 0;
1201 goto exit_dont_set_value;
1203 else if (finalize_syms
1204 && ((final_seg == expr_section && seg_left != expr_section)
1205 || symbol_shadow_p (symp)))
1207 /* If the symbol is an expression symbol, do similarly
1208 as for undefined and common syms above. Handles
1209 "sym +/- expr" where "expr" cannot be evaluated
1210 immediately, and we want relocations to be against
1211 "sym", eg. because it is weak. */
1212 symp->sy_value.X_op = O_symbol;
1213 symp->sy_value.X_add_symbol = add_symbol;
1214 symp->sy_value.X_add_number = final_val;
1215 symp->sy_value.X_op_symbol = add_symbol;
1216 final_seg = seg_left;
1217 final_val += symp->sy_frag->fr_address + left;
1218 resolved = symbol_resolved_p (add_symbol);
1219 symp->sy_resolving = 0;
1220 goto exit_dont_set_value;
1222 else
1224 final_val += symp->sy_frag->fr_address + left;
1225 if (final_seg == expr_section || final_seg == undefined_section)
1226 final_seg = seg_left;
1229 resolved = symbol_resolved_p (add_symbol);
1230 if (S_IS_WEAKREFR (symp))
1231 goto exit_dont_set_value;
1232 break;
1234 case O_uminus:
1235 case O_bit_not:
1236 case O_logical_not:
1237 left = resolve_symbol_value (add_symbol);
1238 seg_left = S_GET_SEGMENT (add_symbol);
1240 /* By reducing these to the relevant dyadic operator, we get
1241 !S -> S == 0 permitted on anything,
1242 -S -> 0 - S only permitted on absolute
1243 ~S -> S ^ ~0 only permitted on absolute */
1244 if (op != O_logical_not && seg_left != absolute_section
1245 && finalize_syms)
1246 report_op_error (symp, add_symbol, NULL);
1248 if (final_seg == expr_section || final_seg == undefined_section)
1249 final_seg = absolute_section;
1251 if (op == O_uminus)
1252 left = -left;
1253 else if (op == O_logical_not)
1254 left = !left;
1255 else
1256 left = ~left;
1258 final_val += left + symp->sy_frag->fr_address;
1260 resolved = symbol_resolved_p (add_symbol);
1261 break;
1263 case O_multiply:
1264 case O_divide:
1265 case O_modulus:
1266 case O_left_shift:
1267 case O_right_shift:
1268 case O_bit_inclusive_or:
1269 case O_bit_or_not:
1270 case O_bit_exclusive_or:
1271 case O_bit_and:
1272 case O_add:
1273 case O_subtract:
1274 case O_eq:
1275 case O_ne:
1276 case O_lt:
1277 case O_le:
1278 case O_ge:
1279 case O_gt:
1280 case O_logical_and:
1281 case O_logical_or:
1282 left = resolve_symbol_value (add_symbol);
1283 right = resolve_symbol_value (op_symbol);
1284 seg_left = S_GET_SEGMENT (add_symbol);
1285 seg_right = S_GET_SEGMENT (op_symbol);
1287 /* Simplify addition or subtraction of a constant by folding the
1288 constant into X_add_number. */
1289 if (op == O_add)
1291 if (seg_right == absolute_section)
1293 final_val += right;
1294 goto do_symbol;
1296 else if (seg_left == absolute_section)
1298 final_val += left;
1299 add_symbol = op_symbol;
1300 left = right;
1301 seg_left = seg_right;
1302 goto do_symbol;
1305 else if (op == O_subtract)
1307 if (seg_right == absolute_section)
1309 final_val -= right;
1310 goto do_symbol;
1314 move_seg_ok = 1;
1315 /* Equality and non-equality tests are permitted on anything.
1316 Subtraction, and other comparison operators are permitted if
1317 both operands are in the same section. Otherwise, both
1318 operands must be absolute. We already handled the case of
1319 addition or subtraction of a constant above. This will
1320 probably need to be changed for an object file format which
1321 supports arbitrary expressions, such as IEEE-695. */
1322 if (!(seg_left == absolute_section
1323 && seg_right == absolute_section)
1324 && !(op == O_eq || op == O_ne)
1325 && !((op == O_subtract
1326 || op == O_lt || op == O_le || op == O_ge || op == O_gt)
1327 && seg_left == seg_right
1328 && (seg_left != undefined_section
1329 || add_symbol == op_symbol)))
1331 /* Don't emit messages unless we're finalizing the symbol value,
1332 otherwise we may get the same message multiple times. */
1333 if (finalize_syms)
1334 report_op_error (symp, add_symbol, op_symbol);
1335 /* However do not move the symbol into the absolute section
1336 if it cannot currently be resolved - this would confuse
1337 other parts of the assembler into believing that the
1338 expression had been evaluated to zero. */
1339 else
1340 move_seg_ok = 0;
1343 if (move_seg_ok
1344 && (final_seg == expr_section || final_seg == undefined_section))
1345 final_seg = absolute_section;
1347 /* Check for division by zero. */
1348 if ((op == O_divide || op == O_modulus) && right == 0)
1350 /* If seg_right is not absolute_section, then we've
1351 already issued a warning about using a bad symbol. */
1352 if (seg_right == absolute_section && finalize_syms)
1354 char *file;
1355 unsigned int line;
1357 if (expr_symbol_where (symp, &file, &line))
1358 as_bad_where (file, line, _("division by zero"));
1359 else
1360 as_bad (_("division by zero when setting `%s'"),
1361 S_GET_NAME (symp));
1364 right = 1;
1367 switch (symp->sy_value.X_op)
1369 case O_multiply: left *= right; break;
1370 case O_divide: left /= right; break;
1371 case O_modulus: left %= right; break;
1372 case O_left_shift: left <<= right; break;
1373 case O_right_shift: left >>= right; break;
1374 case O_bit_inclusive_or: left |= right; break;
1375 case O_bit_or_not: left |= ~right; break;
1376 case O_bit_exclusive_or: left ^= right; break;
1377 case O_bit_and: left &= right; break;
1378 case O_add: left += right; break;
1379 case O_subtract: left -= right; break;
1380 case O_eq:
1381 case O_ne:
1382 left = (left == right && seg_left == seg_right
1383 && (seg_left != undefined_section
1384 || add_symbol == op_symbol)
1385 ? ~ (offsetT) 0 : 0);
1386 if (symp->sy_value.X_op == O_ne)
1387 left = ~left;
1388 break;
1389 case O_lt: left = left < right ? ~ (offsetT) 0 : 0; break;
1390 case O_le: left = left <= right ? ~ (offsetT) 0 : 0; break;
1391 case O_ge: left = left >= right ? ~ (offsetT) 0 : 0; break;
1392 case O_gt: left = left > right ? ~ (offsetT) 0 : 0; break;
1393 case O_logical_and: left = left && right; break;
1394 case O_logical_or: left = left || right; break;
1395 default: abort ();
1398 final_val += symp->sy_frag->fr_address + left;
1399 if (final_seg == expr_section || final_seg == undefined_section)
1401 if (seg_left == undefined_section
1402 || seg_right == undefined_section)
1403 final_seg = undefined_section;
1404 else if (seg_left == absolute_section)
1405 final_seg = seg_right;
1406 else
1407 final_seg = seg_left;
1409 resolved = (symbol_resolved_p (add_symbol)
1410 && symbol_resolved_p (op_symbol));
1411 break;
1413 case O_big:
1414 case O_illegal:
1415 /* Give an error (below) if not in expr_section. We don't
1416 want to worry about expr_section symbols, because they
1417 are fictional (they are created as part of expression
1418 resolution), and any problems may not actually mean
1419 anything. */
1420 break;
1423 symp->sy_resolving = 0;
1426 if (finalize_syms)
1427 S_SET_VALUE (symp, final_val);
1429 exit_dont_set_value:
1430 /* Always set the segment, even if not finalizing the value.
1431 The segment is used to determine whether a symbol is defined. */
1432 S_SET_SEGMENT (symp, final_seg);
1434 /* Don't worry if we can't resolve an expr_section symbol. */
1435 if (finalize_syms)
1437 if (resolved)
1438 symp->sy_resolved = 1;
1439 else if (S_GET_SEGMENT (symp) != expr_section)
1441 as_bad (_("can't resolve value for symbol `%s'"),
1442 S_GET_NAME (symp));
1443 symp->sy_resolved = 1;
1447 return final_val;
1450 static void resolve_local_symbol (const char *, void *);
1452 /* A static function passed to hash_traverse. */
1454 static void
1455 resolve_local_symbol (const char *key ATTRIBUTE_UNUSED, void *value)
1457 if (value != NULL)
1458 resolve_symbol_value ((symbolS *) value);
1461 /* Resolve all local symbols. */
1463 void
1464 resolve_local_symbol_values (void)
1466 hash_traverse (local_hash, resolve_local_symbol);
1469 /* Obtain the current value of a symbol without changing any
1470 sub-expressions used. */
1473 snapshot_symbol (symbolS **symbolPP, valueT *valueP, segT *segP, fragS **fragPP)
1475 symbolS *symbolP = *symbolPP;
1477 if (LOCAL_SYMBOL_CHECK (symbolP))
1479 struct local_symbol *locsym = (struct local_symbol *) symbolP;
1481 *valueP = locsym->lsy_value;
1482 *segP = locsym->lsy_section;
1483 *fragPP = local_symbol_get_frag (locsym);
1485 else
1487 expressionS exp = symbolP->sy_value;
1489 if (!symbolP->sy_resolved && exp.X_op != O_illegal)
1491 int resolved;
1493 if (symbolP->sy_resolving)
1494 return 0;
1495 symbolP->sy_resolving = 1;
1496 resolved = resolve_expression (&exp);
1497 symbolP->sy_resolving = 0;
1498 if (!resolved)
1499 return 0;
1501 switch (exp.X_op)
1503 case O_constant:
1504 case O_register:
1505 if (!symbol_equated_p (symbolP))
1506 break;
1507 /* Fall thru. */
1508 case O_symbol:
1509 case O_symbol_rva:
1510 symbolP = exp.X_add_symbol;
1511 break;
1512 default:
1513 return 0;
1517 *symbolPP = symbolP;
1518 *valueP = exp.X_add_number;
1519 *segP = symbolP->bsym->section;
1520 *fragPP = symbolP->sy_frag;
1522 if (*segP == expr_section)
1523 switch (exp.X_op)
1525 case O_constant: *segP = absolute_section; break;
1526 case O_register: *segP = reg_section; break;
1527 default: break;
1531 return 1;
1534 /* Dollar labels look like a number followed by a dollar sign. Eg, "42$".
1535 They are *really* local. That is, they go out of scope whenever we see a
1536 label that isn't local. Also, like fb labels, there can be multiple
1537 instances of a dollar label. Therefor, we name encode each instance with
1538 the instance number, keep a list of defined symbols separate from the real
1539 symbol table, and we treat these buggers as a sparse array. */
1541 static long *dollar_labels;
1542 static long *dollar_label_instances;
1543 static char *dollar_label_defines;
1544 static unsigned long dollar_label_count;
1545 static unsigned long dollar_label_max;
1548 dollar_label_defined (long label)
1550 long *i;
1552 know ((dollar_labels != NULL) || (dollar_label_count == 0));
1554 for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
1555 if (*i == label)
1556 return dollar_label_defines[i - dollar_labels];
1558 /* If we get here, label isn't defined. */
1559 return 0;
1562 static long
1563 dollar_label_instance (long label)
1565 long *i;
1567 know ((dollar_labels != NULL) || (dollar_label_count == 0));
1569 for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
1570 if (*i == label)
1571 return (dollar_label_instances[i - dollar_labels]);
1573 /* If we get here, we haven't seen the label before.
1574 Therefore its instance count is zero. */
1575 return 0;
1578 void
1579 dollar_label_clear (void)
1581 memset (dollar_label_defines, '\0', (unsigned int) dollar_label_count);
1584 #define DOLLAR_LABEL_BUMP_BY 10
1586 void
1587 define_dollar_label (long label)
1589 long *i;
1591 for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
1592 if (*i == label)
1594 ++dollar_label_instances[i - dollar_labels];
1595 dollar_label_defines[i - dollar_labels] = 1;
1596 return;
1599 /* If we get to here, we don't have label listed yet. */
1601 if (dollar_labels == NULL)
1603 dollar_labels = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long));
1604 dollar_label_instances = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long));
1605 dollar_label_defines = (char *) xmalloc (DOLLAR_LABEL_BUMP_BY);
1606 dollar_label_max = DOLLAR_LABEL_BUMP_BY;
1607 dollar_label_count = 0;
1609 else if (dollar_label_count == dollar_label_max)
1611 dollar_label_max += DOLLAR_LABEL_BUMP_BY;
1612 dollar_labels = (long *) xrealloc ((char *) dollar_labels,
1613 dollar_label_max * sizeof (long));
1614 dollar_label_instances = (long *) xrealloc ((char *) dollar_label_instances,
1615 dollar_label_max * sizeof (long));
1616 dollar_label_defines = (char *) xrealloc (dollar_label_defines, dollar_label_max);
1617 } /* if we needed to grow */
1619 dollar_labels[dollar_label_count] = label;
1620 dollar_label_instances[dollar_label_count] = 1;
1621 dollar_label_defines[dollar_label_count] = 1;
1622 ++dollar_label_count;
1625 /* Caller must copy returned name: we re-use the area for the next name.
1627 The mth occurence of label n: is turned into the symbol "Ln^Am"
1628 where n is the label number and m is the instance number. "L" makes
1629 it a label discarded unless debugging and "^A"('\1') ensures no
1630 ordinary symbol SHOULD get the same name as a local label
1631 symbol. The first "4:" is "L4^A1" - the m numbers begin at 1.
1633 fb labels get the same treatment, except that ^B is used in place
1634 of ^A. */
1636 char * /* Return local label name. */
1637 dollar_label_name (register long n, /* we just saw "n$:" : n a number. */
1638 register int augend /* 0 for current instance, 1 for new instance. */)
1640 long i;
1641 /* Returned to caller, then copied. Used for created names ("4f"). */
1642 static char symbol_name_build[24];
1643 register char *p;
1644 register char *q;
1645 char symbol_name_temporary[20]; /* Build up a number, BACKWARDS. */
1647 know (n >= 0);
1648 know (augend == 0 || augend == 1);
1649 p = symbol_name_build;
1650 #ifdef LOCAL_LABEL_PREFIX
1651 *p++ = LOCAL_LABEL_PREFIX;
1652 #endif
1653 *p++ = 'L';
1655 /* Next code just does sprintf( {}, "%d", n); */
1656 /* Label number. */
1657 q = symbol_name_temporary;
1658 for (*q++ = 0, i = n; i; ++q)
1660 *q = i % 10 + '0';
1661 i /= 10;
1663 while ((*p = *--q) != '\0')
1664 ++p;
1666 *p++ = DOLLAR_LABEL_CHAR; /* ^A */
1668 /* Instance number. */
1669 q = symbol_name_temporary;
1670 for (*q++ = 0, i = dollar_label_instance (n) + augend; i; ++q)
1672 *q = i % 10 + '0';
1673 i /= 10;
1675 while ((*p++ = *--q) != '\0');;
1677 /* The label, as a '\0' ended string, starts at symbol_name_build. */
1678 return symbol_name_build;
1681 /* Somebody else's idea of local labels. They are made by "n:" where n
1682 is any decimal digit. Refer to them with
1683 "nb" for previous (backward) n:
1684 or "nf" for next (forward) n:.
1686 We do a little better and let n be any number, not just a single digit, but
1687 since the other guy's assembler only does ten, we treat the first ten
1688 specially.
1690 Like someone else's assembler, we have one set of local label counters for
1691 entire assembly, not one set per (sub)segment like in most assemblers. This
1692 implies that one can refer to a label in another segment, and indeed some
1693 crufty compilers have done just that.
1695 Since there could be a LOT of these things, treat them as a sparse
1696 array. */
1698 #define FB_LABEL_SPECIAL (10)
1700 static long fb_low_counter[FB_LABEL_SPECIAL];
1701 static long *fb_labels;
1702 static long *fb_label_instances;
1703 static long fb_label_count;
1704 static long fb_label_max;
1706 /* This must be more than FB_LABEL_SPECIAL. */
1707 #define FB_LABEL_BUMP_BY (FB_LABEL_SPECIAL + 6)
1709 static void
1710 fb_label_init (void)
1712 memset ((void *) fb_low_counter, '\0', sizeof (fb_low_counter));
1715 /* Add one to the instance number of this fb label. */
1717 void
1718 fb_label_instance_inc (long label)
1720 long *i;
1722 if (label < FB_LABEL_SPECIAL)
1724 ++fb_low_counter[label];
1725 return;
1728 if (fb_labels != NULL)
1730 for (i = fb_labels + FB_LABEL_SPECIAL;
1731 i < fb_labels + fb_label_count; ++i)
1733 if (*i == label)
1735 ++fb_label_instances[i - fb_labels];
1736 return;
1737 } /* if we find it */
1738 } /* for each existing label */
1741 /* If we get to here, we don't have label listed yet. */
1743 if (fb_labels == NULL)
1745 fb_labels = (long *) xmalloc (FB_LABEL_BUMP_BY * sizeof (long));
1746 fb_label_instances = (long *) xmalloc (FB_LABEL_BUMP_BY * sizeof (long));
1747 fb_label_max = FB_LABEL_BUMP_BY;
1748 fb_label_count = FB_LABEL_SPECIAL;
1751 else if (fb_label_count == fb_label_max)
1753 fb_label_max += FB_LABEL_BUMP_BY;
1754 fb_labels = (long *) xrealloc ((char *) fb_labels,
1755 fb_label_max * sizeof (long));
1756 fb_label_instances = (long *) xrealloc ((char *) fb_label_instances,
1757 fb_label_max * sizeof (long));
1758 } /* if we needed to grow */
1760 fb_labels[fb_label_count] = label;
1761 fb_label_instances[fb_label_count] = 1;
1762 ++fb_label_count;
1765 static long
1766 fb_label_instance (long label)
1768 long *i;
1770 if (label < FB_LABEL_SPECIAL)
1772 return (fb_low_counter[label]);
1775 if (fb_labels != NULL)
1777 for (i = fb_labels + FB_LABEL_SPECIAL;
1778 i < fb_labels + fb_label_count; ++i)
1780 if (*i == label)
1782 return (fb_label_instances[i - fb_labels]);
1783 } /* if we find it */
1784 } /* for each existing label */
1787 /* We didn't find the label, so this must be a reference to the
1788 first instance. */
1789 return 0;
1792 /* Caller must copy returned name: we re-use the area for the next name.
1794 The mth occurence of label n: is turned into the symbol "Ln^Bm"
1795 where n is the label number and m is the instance number. "L" makes
1796 it a label discarded unless debugging and "^B"('\2') ensures no
1797 ordinary symbol SHOULD get the same name as a local label
1798 symbol. The first "4:" is "L4^B1" - the m numbers begin at 1.
1800 dollar labels get the same treatment, except that ^A is used in
1801 place of ^B. */
1803 char * /* Return local label name. */
1804 fb_label_name (long n, /* We just saw "n:", "nf" or "nb" : n a number. */
1805 long augend /* 0 for nb, 1 for n:, nf. */)
1807 long i;
1808 /* Returned to caller, then copied. Used for created names ("4f"). */
1809 static char symbol_name_build[24];
1810 register char *p;
1811 register char *q;
1812 char symbol_name_temporary[20]; /* Build up a number, BACKWARDS. */
1814 know (n >= 0);
1815 #ifdef TC_MMIX
1816 know ((unsigned long) augend <= 2 /* See mmix_fb_label. */);
1817 #else
1818 know ((unsigned long) augend <= 1);
1819 #endif
1820 p = symbol_name_build;
1821 #ifdef LOCAL_LABEL_PREFIX
1822 *p++ = LOCAL_LABEL_PREFIX;
1823 #endif
1824 *p++ = 'L';
1826 /* Next code just does sprintf( {}, "%d", n); */
1827 /* Label number. */
1828 q = symbol_name_temporary;
1829 for (*q++ = 0, i = n; i; ++q)
1831 *q = i % 10 + '0';
1832 i /= 10;
1834 while ((*p = *--q) != '\0')
1835 ++p;
1837 *p++ = LOCAL_LABEL_CHAR; /* ^B */
1839 /* Instance number. */
1840 q = symbol_name_temporary;
1841 for (*q++ = 0, i = fb_label_instance (n) + augend; i; ++q)
1843 *q = i % 10 + '0';
1844 i /= 10;
1846 while ((*p++ = *--q) != '\0');;
1848 /* The label, as a '\0' ended string, starts at symbol_name_build. */
1849 return (symbol_name_build);
1852 /* Decode name that may have been generated by foo_label_name() above.
1853 If the name wasn't generated by foo_label_name(), then return it
1854 unaltered. This is used for error messages. */
1856 char *
1857 decode_local_label_name (char *s)
1859 char *p;
1860 char *symbol_decode;
1861 int label_number;
1862 int instance_number;
1863 char *type;
1864 const char *message_format;
1865 int lindex = 0;
1867 #ifdef LOCAL_LABEL_PREFIX
1868 if (s[lindex] == LOCAL_LABEL_PREFIX)
1869 ++lindex;
1870 #endif
1872 if (s[lindex] != 'L')
1873 return s;
1875 for (label_number = 0, p = s + lindex + 1; ISDIGIT (*p); ++p)
1876 label_number = (10 * label_number) + *p - '0';
1878 if (*p == DOLLAR_LABEL_CHAR)
1879 type = "dollar";
1880 else if (*p == LOCAL_LABEL_CHAR)
1881 type = "fb";
1882 else
1883 return s;
1885 for (instance_number = 0, p++; ISDIGIT (*p); ++p)
1886 instance_number = (10 * instance_number) + *p - '0';
1888 message_format = _("\"%d\" (instance number %d of a %s label)");
1889 symbol_decode = (char *) obstack_alloc (&notes, strlen (message_format) + 30);
1890 sprintf (symbol_decode, message_format, label_number, instance_number, type);
1892 return symbol_decode;
1895 /* Get the value of a symbol. */
1897 valueT
1898 S_GET_VALUE (symbolS *s)
1900 if (LOCAL_SYMBOL_CHECK (s))
1901 return resolve_symbol_value (s);
1903 if (!s->sy_resolved)
1905 valueT val = resolve_symbol_value (s);
1906 if (!finalize_syms)
1907 return val;
1909 if (S_IS_WEAKREFR (s))
1910 return S_GET_VALUE (s->sy_value.X_add_symbol);
1912 if (s->sy_value.X_op != O_constant)
1914 if (! s->sy_resolved
1915 || s->sy_value.X_op != O_symbol
1916 || (S_IS_DEFINED (s) && ! S_IS_COMMON (s)))
1917 as_bad (_("attempt to get value of unresolved symbol `%s'"),
1918 S_GET_NAME (s));
1920 return (valueT) s->sy_value.X_add_number;
1923 /* Set the value of a symbol. */
1925 void
1926 S_SET_VALUE (symbolS *s, valueT val)
1928 if (LOCAL_SYMBOL_CHECK (s))
1930 ((struct local_symbol *) s)->lsy_value = val;
1931 return;
1934 s->sy_value.X_op = O_constant;
1935 s->sy_value.X_add_number = (offsetT) val;
1936 s->sy_value.X_unsigned = 0;
1937 S_CLEAR_WEAKREFR (s);
1940 void
1941 copy_symbol_attributes (symbolS *dest, symbolS *src)
1943 if (LOCAL_SYMBOL_CHECK (dest))
1944 dest = local_symbol_convert ((struct local_symbol *) dest);
1945 if (LOCAL_SYMBOL_CHECK (src))
1946 src = local_symbol_convert ((struct local_symbol *) src);
1948 /* In an expression, transfer the settings of these flags.
1949 The user can override later, of course. */
1950 #define COPIED_SYMFLAGS (BSF_FUNCTION | BSF_OBJECT \
1951 | BSF_GNU_INDIRECT_FUNCTION)
1952 dest->bsym->flags |= src->bsym->flags & COPIED_SYMFLAGS;
1954 #ifdef OBJ_COPY_SYMBOL_ATTRIBUTES
1955 OBJ_COPY_SYMBOL_ATTRIBUTES (dest, src);
1956 #endif
1958 #ifdef TC_COPY_SYMBOL_ATTRIBUTES
1959 TC_COPY_SYMBOL_ATTRIBUTES (dest, src);
1960 #endif
1964 S_IS_FUNCTION (symbolS *s)
1966 flagword flags;
1968 if (LOCAL_SYMBOL_CHECK (s))
1969 return 0;
1971 flags = s->bsym->flags;
1973 return (flags & BSF_FUNCTION) != 0;
1977 S_IS_EXTERNAL (symbolS *s)
1979 flagword flags;
1981 if (LOCAL_SYMBOL_CHECK (s))
1982 return 0;
1984 flags = s->bsym->flags;
1986 /* Sanity check. */
1987 if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL))
1988 abort ();
1990 return (flags & BSF_GLOBAL) != 0;
1994 S_IS_WEAK (symbolS *s)
1996 if (LOCAL_SYMBOL_CHECK (s))
1997 return 0;
1998 /* Conceptually, a weakrefr is weak if the referenced symbol is. We
1999 could probably handle a WEAKREFR as always weak though. E.g., if
2000 the referenced symbol has lost its weak status, there's no reason
2001 to keep handling the weakrefr as if it was weak. */
2002 if (S_IS_WEAKREFR (s))
2003 return S_IS_WEAK (s->sy_value.X_add_symbol);
2004 return (s->bsym->flags & BSF_WEAK) != 0;
2008 S_IS_WEAKREFR (symbolS *s)
2010 if (LOCAL_SYMBOL_CHECK (s))
2011 return 0;
2012 return s->sy_weakrefr != 0;
2016 S_IS_WEAKREFD (symbolS *s)
2018 if (LOCAL_SYMBOL_CHECK (s))
2019 return 0;
2020 return s->sy_weakrefd != 0;
2024 S_IS_COMMON (symbolS *s)
2026 if (LOCAL_SYMBOL_CHECK (s))
2027 return 0;
2028 return bfd_is_com_section (s->bsym->section);
2032 S_IS_DEFINED (symbolS *s)
2034 if (LOCAL_SYMBOL_CHECK (s))
2035 return ((struct local_symbol *) s)->lsy_section != undefined_section;
2036 return s->bsym->section != undefined_section;
2040 #ifndef EXTERN_FORCE_RELOC
2041 #define EXTERN_FORCE_RELOC IS_ELF
2042 #endif
2044 /* Return true for symbols that should not be reduced to section
2045 symbols or eliminated from expressions, because they may be
2046 overridden by the linker. */
2048 S_FORCE_RELOC (symbolS *s, int strict)
2050 if (LOCAL_SYMBOL_CHECK (s))
2051 return ((struct local_symbol *) s)->lsy_section == undefined_section;
2053 return ((strict
2054 && ((s->bsym->flags & BSF_WEAK) != 0
2055 || (s->bsym->flags & BSF_GNU_INDIRECT_FUNCTION) != 0
2056 || (EXTERN_FORCE_RELOC
2057 && (s->bsym->flags & BSF_GLOBAL) != 0)))
2058 || s->bsym->section == undefined_section
2059 || bfd_is_com_section (s->bsym->section));
2063 S_IS_DEBUG (symbolS *s)
2065 if (LOCAL_SYMBOL_CHECK (s))
2066 return 0;
2067 if (s->bsym->flags & BSF_DEBUGGING)
2068 return 1;
2069 return 0;
2073 S_IS_LOCAL (symbolS *s)
2075 flagword flags;
2076 const char *name;
2078 if (LOCAL_SYMBOL_CHECK (s))
2079 return 1;
2081 flags = s->bsym->flags;
2083 /* Sanity check. */
2084 if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL))
2085 abort ();
2087 if (bfd_get_section (s->bsym) == reg_section)
2088 return 1;
2090 if (flag_strip_local_absolute
2091 /* Keep BSF_FILE symbols in order to allow debuggers to identify
2092 the source file even when the object file is stripped. */
2093 && (flags & (BSF_GLOBAL | BSF_FILE)) == 0
2094 && bfd_get_section (s->bsym) == absolute_section)
2095 return 1;
2097 name = S_GET_NAME (s);
2098 return (name != NULL
2099 && ! S_IS_DEBUG (s)
2100 && (strchr (name, DOLLAR_LABEL_CHAR)
2101 || strchr (name, LOCAL_LABEL_CHAR)
2102 || (! flag_keep_locals
2103 && (bfd_is_local_label (stdoutput, s->bsym)
2104 || (flag_mri
2105 && name[0] == '?'
2106 && name[1] == '?')))));
2110 S_IS_STABD (symbolS *s)
2112 return S_GET_NAME (s) == 0;
2116 S_IS_VOLATILE (const symbolS *s)
2118 if (LOCAL_SYMBOL_CHECK (s))
2119 return 0;
2120 return s->sy_volatile;
2124 S_IS_FORWARD_REF (const symbolS *s)
2126 if (LOCAL_SYMBOL_CHECK (s))
2127 return 0;
2128 return s->sy_forward_ref;
2131 const char *
2132 S_GET_NAME (symbolS *s)
2134 if (LOCAL_SYMBOL_CHECK (s))
2135 return ((struct local_symbol *) s)->lsy_name;
2136 return s->bsym->name;
2139 segT
2140 S_GET_SEGMENT (symbolS *s)
2142 if (LOCAL_SYMBOL_CHECK (s))
2143 return ((struct local_symbol *) s)->lsy_section;
2144 return s->bsym->section;
2147 void
2148 S_SET_SEGMENT (symbolS *s, segT seg)
2150 /* Don't reassign section symbols. The direct reason is to prevent seg
2151 faults assigning back to const global symbols such as *ABS*, but it
2152 shouldn't happen anyway. */
2154 if (LOCAL_SYMBOL_CHECK (s))
2156 if (seg == reg_section)
2157 s = local_symbol_convert ((struct local_symbol *) s);
2158 else
2160 ((struct local_symbol *) s)->lsy_section = seg;
2161 return;
2165 if (s->bsym->flags & BSF_SECTION_SYM)
2167 if (s->bsym->section != seg)
2168 abort ();
2170 else
2171 s->bsym->section = seg;
2174 void
2175 S_SET_EXTERNAL (symbolS *s)
2177 if (LOCAL_SYMBOL_CHECK (s))
2178 s = local_symbol_convert ((struct local_symbol *) s);
2179 if ((s->bsym->flags & BSF_WEAK) != 0)
2181 /* Let .weak override .global. */
2182 return;
2184 if (s->bsym->flags & BSF_SECTION_SYM)
2186 char * file;
2187 unsigned int line;
2189 /* Do not reassign section symbols. */
2190 as_where (& file, & line);
2191 as_warn_where (file, line,
2192 _("section symbols are already global"));
2193 return;
2195 #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
2196 if (S_GET_SEGMENT (s) == reg_section)
2198 as_bad ("can't make register symbol `%s' global",
2199 S_GET_NAME (s));
2200 return;
2202 #endif
2203 s->bsym->flags |= BSF_GLOBAL;
2204 s->bsym->flags &= ~(BSF_LOCAL | BSF_WEAK);
2206 #ifdef TE_PE
2207 if (! an_external_name && S_GET_NAME(s)[0] != '.')
2208 an_external_name = S_GET_NAME (s);
2209 #endif
2212 void
2213 S_CLEAR_EXTERNAL (symbolS *s)
2215 if (LOCAL_SYMBOL_CHECK (s))
2216 return;
2217 if ((s->bsym->flags & BSF_WEAK) != 0)
2219 /* Let .weak override. */
2220 return;
2222 s->bsym->flags |= BSF_LOCAL;
2223 s->bsym->flags &= ~(BSF_GLOBAL | BSF_WEAK);
2226 void
2227 S_SET_WEAK (symbolS *s)
2229 if (LOCAL_SYMBOL_CHECK (s))
2230 s = local_symbol_convert ((struct local_symbol *) s);
2231 #ifdef obj_set_weak_hook
2232 obj_set_weak_hook (s);
2233 #endif
2234 s->bsym->flags |= BSF_WEAK;
2235 s->bsym->flags &= ~(BSF_GLOBAL | BSF_LOCAL);
2238 void
2239 S_SET_WEAKREFR (symbolS *s)
2241 if (LOCAL_SYMBOL_CHECK (s))
2242 s = local_symbol_convert ((struct local_symbol *) s);
2243 s->sy_weakrefr = 1;
2244 /* If the alias was already used, make sure we mark the target as
2245 used as well, otherwise it might be dropped from the symbol
2246 table. This may have unintended side effects if the alias is
2247 later redirected to another symbol, such as keeping the unused
2248 previous target in the symbol table. Since it will be weak, it's
2249 not a big deal. */
2250 if (s->sy_used)
2251 symbol_mark_used (s->sy_value.X_add_symbol);
2254 void
2255 S_CLEAR_WEAKREFR (symbolS *s)
2257 if (LOCAL_SYMBOL_CHECK (s))
2258 return;
2259 s->sy_weakrefr = 0;
2262 void
2263 S_SET_WEAKREFD (symbolS *s)
2265 if (LOCAL_SYMBOL_CHECK (s))
2266 s = local_symbol_convert ((struct local_symbol *) s);
2267 s->sy_weakrefd = 1;
2268 S_SET_WEAK (s);
2271 void
2272 S_CLEAR_WEAKREFD (symbolS *s)
2274 if (LOCAL_SYMBOL_CHECK (s))
2275 return;
2276 if (s->sy_weakrefd)
2278 s->sy_weakrefd = 0;
2279 /* If a weakref target symbol is weak, then it was never
2280 referenced directly before, not even in a .global directive,
2281 so decay it to local. If it remains undefined, it will be
2282 later turned into a global, like any other undefined
2283 symbol. */
2284 if (s->bsym->flags & BSF_WEAK)
2286 #ifdef obj_clear_weak_hook
2287 obj_clear_weak_hook (s);
2288 #endif
2289 s->bsym->flags &= ~BSF_WEAK;
2290 s->bsym->flags |= BSF_LOCAL;
2295 void
2296 S_SET_THREAD_LOCAL (symbolS *s)
2298 if (LOCAL_SYMBOL_CHECK (s))
2299 s = local_symbol_convert ((struct local_symbol *) s);
2300 if (bfd_is_com_section (s->bsym->section)
2301 && (s->bsym->flags & BSF_THREAD_LOCAL) != 0)
2302 return;
2303 s->bsym->flags |= BSF_THREAD_LOCAL;
2304 if ((s->bsym->flags & BSF_FUNCTION) != 0)
2305 as_bad (_("Accessing function `%s' as thread-local object"),
2306 S_GET_NAME (s));
2307 else if (! bfd_is_und_section (s->bsym->section)
2308 && (s->bsym->section->flags & SEC_THREAD_LOCAL) == 0)
2309 as_bad (_("Accessing `%s' as thread-local object"),
2310 S_GET_NAME (s));
2313 void
2314 S_SET_NAME (symbolS *s, const char *name)
2316 if (LOCAL_SYMBOL_CHECK (s))
2318 ((struct local_symbol *) s)->lsy_name = name;
2319 return;
2321 s->bsym->name = name;
2324 void
2325 S_SET_VOLATILE (symbolS *s)
2327 if (LOCAL_SYMBOL_CHECK (s))
2328 s = local_symbol_convert ((struct local_symbol *) s);
2329 s->sy_volatile = 1;
2332 void
2333 S_CLEAR_VOLATILE (symbolS *s)
2335 if (!LOCAL_SYMBOL_CHECK (s))
2336 s->sy_volatile = 0;
2339 void
2340 S_SET_FORWARD_REF (symbolS *s)
2342 if (LOCAL_SYMBOL_CHECK (s))
2343 s = local_symbol_convert ((struct local_symbol *) s);
2344 s->sy_forward_ref = 1;
2347 /* Return the previous symbol in a chain. */
2349 symbolS *
2350 symbol_previous (symbolS *s)
2352 if (LOCAL_SYMBOL_CHECK (s))
2353 abort ();
2354 return s->sy_previous;
2357 /* Return the next symbol in a chain. */
2359 symbolS *
2360 symbol_next (symbolS *s)
2362 if (LOCAL_SYMBOL_CHECK (s))
2363 abort ();
2364 return s->sy_next;
2367 /* Return a pointer to the value of a symbol as an expression. */
2369 expressionS *
2370 symbol_get_value_expression (symbolS *s)
2372 if (LOCAL_SYMBOL_CHECK (s))
2373 s = local_symbol_convert ((struct local_symbol *) s);
2374 return &s->sy_value;
2377 /* Set the value of a symbol to an expression. */
2379 void
2380 symbol_set_value_expression (symbolS *s, const expressionS *exp)
2382 if (LOCAL_SYMBOL_CHECK (s))
2383 s = local_symbol_convert ((struct local_symbol *) s);
2384 s->sy_value = *exp;
2385 S_CLEAR_WEAKREFR (s);
2388 /* Return whether 2 symbols are the same. */
2391 symbol_same_p (symbolS *s1, symbolS *s2)
2393 if (s1->bsym == NULL
2394 && local_symbol_converted_p ((struct local_symbol *) s1))
2395 s1 = local_symbol_get_real_symbol ((struct local_symbol *) s1);
2396 if (s2->bsym == NULL
2397 && local_symbol_converted_p ((struct local_symbol *) s2))
2398 s2 = local_symbol_get_real_symbol ((struct local_symbol *) s2);
2399 return s1 == s2;
2402 /* Return a pointer to the X_add_number component of a symbol. */
2404 offsetT *
2405 symbol_X_add_number (symbolS *s)
2407 if (LOCAL_SYMBOL_CHECK (s))
2408 return (offsetT *) &((struct local_symbol *) s)->lsy_value;
2410 return &s->sy_value.X_add_number;
2413 /* Set the value of SYM to the current position in the current segment. */
2415 void
2416 symbol_set_value_now (symbolS *sym)
2418 S_SET_SEGMENT (sym, now_seg);
2419 S_SET_VALUE (sym, frag_now_fix ());
2420 symbol_set_frag (sym, frag_now);
2423 /* Set the frag of a symbol. */
2425 void
2426 symbol_set_frag (symbolS *s, fragS *f)
2428 if (LOCAL_SYMBOL_CHECK (s))
2430 local_symbol_set_frag ((struct local_symbol *) s, f);
2431 return;
2433 s->sy_frag = f;
2434 S_CLEAR_WEAKREFR (s);
2437 /* Return the frag of a symbol. */
2439 fragS *
2440 symbol_get_frag (symbolS *s)
2442 if (LOCAL_SYMBOL_CHECK (s))
2443 return local_symbol_get_frag ((struct local_symbol *) s);
2444 return s->sy_frag;
2447 /* Mark a symbol as having been used. */
2449 void
2450 symbol_mark_used (symbolS *s)
2452 if (LOCAL_SYMBOL_CHECK (s))
2453 return;
2454 s->sy_used = 1;
2455 if (S_IS_WEAKREFR (s))
2456 symbol_mark_used (s->sy_value.X_add_symbol);
2459 /* Clear the mark of whether a symbol has been used. */
2461 void
2462 symbol_clear_used (symbolS *s)
2464 if (LOCAL_SYMBOL_CHECK (s))
2465 s = local_symbol_convert ((struct local_symbol *) s);
2466 s->sy_used = 0;
2469 /* Return whether a symbol has been used. */
2472 symbol_used_p (symbolS *s)
2474 if (LOCAL_SYMBOL_CHECK (s))
2475 return 1;
2476 return s->sy_used;
2479 /* Mark a symbol as having been used in a reloc. */
2481 void
2482 symbol_mark_used_in_reloc (symbolS *s)
2484 if (LOCAL_SYMBOL_CHECK (s))
2485 s = local_symbol_convert ((struct local_symbol *) s);
2486 s->sy_used_in_reloc = 1;
2489 /* Clear the mark of whether a symbol has been used in a reloc. */
2491 void
2492 symbol_clear_used_in_reloc (symbolS *s)
2494 if (LOCAL_SYMBOL_CHECK (s))
2495 return;
2496 s->sy_used_in_reloc = 0;
2499 /* Return whether a symbol has been used in a reloc. */
2502 symbol_used_in_reloc_p (symbolS *s)
2504 if (LOCAL_SYMBOL_CHECK (s))
2505 return 0;
2506 return s->sy_used_in_reloc;
2509 /* Mark a symbol as an MRI common symbol. */
2511 void
2512 symbol_mark_mri_common (symbolS *s)
2514 if (LOCAL_SYMBOL_CHECK (s))
2515 s = local_symbol_convert ((struct local_symbol *) s);
2516 s->sy_mri_common = 1;
2519 /* Clear the mark of whether a symbol is an MRI common symbol. */
2521 void
2522 symbol_clear_mri_common (symbolS *s)
2524 if (LOCAL_SYMBOL_CHECK (s))
2525 return;
2526 s->sy_mri_common = 0;
2529 /* Return whether a symbol is an MRI common symbol. */
2532 symbol_mri_common_p (symbolS *s)
2534 if (LOCAL_SYMBOL_CHECK (s))
2535 return 0;
2536 return s->sy_mri_common;
2539 /* Mark a symbol as having been written. */
2541 void
2542 symbol_mark_written (symbolS *s)
2544 if (LOCAL_SYMBOL_CHECK (s))
2545 return;
2546 s->written = 1;
2549 /* Clear the mark of whether a symbol has been written. */
2551 void
2552 symbol_clear_written (symbolS *s)
2554 if (LOCAL_SYMBOL_CHECK (s))
2555 return;
2556 s->written = 0;
2559 /* Return whether a symbol has been written. */
2562 symbol_written_p (symbolS *s)
2564 if (LOCAL_SYMBOL_CHECK (s))
2565 return 0;
2566 return s->written;
2569 /* Mark a symbol has having been resolved. */
2571 void
2572 symbol_mark_resolved (symbolS *s)
2574 if (LOCAL_SYMBOL_CHECK (s))
2576 local_symbol_mark_resolved ((struct local_symbol *) s);
2577 return;
2579 s->sy_resolved = 1;
2582 /* Return whether a symbol has been resolved. */
2585 symbol_resolved_p (symbolS *s)
2587 if (LOCAL_SYMBOL_CHECK (s))
2588 return local_symbol_resolved_p ((struct local_symbol *) s);
2589 return s->sy_resolved;
2592 /* Return whether a symbol is a section symbol. */
2595 symbol_section_p (symbolS *s ATTRIBUTE_UNUSED)
2597 if (LOCAL_SYMBOL_CHECK (s))
2598 return 0;
2599 return (s->bsym->flags & BSF_SECTION_SYM) != 0;
2602 /* Return whether a symbol is equated to another symbol. */
2605 symbol_equated_p (symbolS *s)
2607 if (LOCAL_SYMBOL_CHECK (s))
2608 return 0;
2609 return s->sy_value.X_op == O_symbol;
2612 /* Return whether a symbol is equated to another symbol, and should be
2613 treated specially when writing out relocs. */
2616 symbol_equated_reloc_p (symbolS *s)
2618 if (LOCAL_SYMBOL_CHECK (s))
2619 return 0;
2620 /* X_op_symbol, normally not used for O_symbol, is set by
2621 resolve_symbol_value to flag expression syms that have been
2622 equated. */
2623 return (s->sy_value.X_op == O_symbol
2624 #if defined (OBJ_COFF) && defined (TE_PE)
2625 && ! S_IS_WEAK (s)
2626 #endif
2627 && ((s->sy_resolved && s->sy_value.X_op_symbol != NULL)
2628 || ! S_IS_DEFINED (s)
2629 || S_IS_COMMON (s)));
2632 /* Return whether a symbol has a constant value. */
2635 symbol_constant_p (symbolS *s)
2637 if (LOCAL_SYMBOL_CHECK (s))
2638 return 1;
2639 return s->sy_value.X_op == O_constant;
2642 /* Return whether a symbol was cloned and thus removed from the global
2643 symbol list. */
2646 symbol_shadow_p (symbolS *s)
2648 if (LOCAL_SYMBOL_CHECK (s))
2649 return 0;
2650 return s->sy_next == s;
2653 /* Return the BFD symbol for a symbol. */
2655 asymbol *
2656 symbol_get_bfdsym (symbolS *s)
2658 if (LOCAL_SYMBOL_CHECK (s))
2659 s = local_symbol_convert ((struct local_symbol *) s);
2660 return s->bsym;
2663 /* Set the BFD symbol for a symbol. */
2665 void
2666 symbol_set_bfdsym (symbolS *s, asymbol *bsym)
2668 if (LOCAL_SYMBOL_CHECK (s))
2669 s = local_symbol_convert ((struct local_symbol *) s);
2670 /* Usually, it is harmless to reset a symbol to a BFD section
2671 symbol. For example, obj_elf_change_section sets the BFD symbol
2672 of an old symbol with the newly created section symbol. But when
2673 we have multiple sections with the same name, the newly created
2674 section may have the same name as an old section. We check if the
2675 old symbol has been already marked as a section symbol before
2676 resetting it. */
2677 if ((s->bsym->flags & BSF_SECTION_SYM) == 0)
2678 s->bsym = bsym;
2679 /* else XXX - What do we do now ? */
2682 #ifdef OBJ_SYMFIELD_TYPE
2684 /* Get a pointer to the object format information for a symbol. */
2686 OBJ_SYMFIELD_TYPE *
2687 symbol_get_obj (symbolS *s)
2689 if (LOCAL_SYMBOL_CHECK (s))
2690 s = local_symbol_convert ((struct local_symbol *) s);
2691 return &s->sy_obj;
2694 /* Set the object format information for a symbol. */
2696 void
2697 symbol_set_obj (symbolS *s, OBJ_SYMFIELD_TYPE *o)
2699 if (LOCAL_SYMBOL_CHECK (s))
2700 s = local_symbol_convert ((struct local_symbol *) s);
2701 s->sy_obj = *o;
2704 #endif /* OBJ_SYMFIELD_TYPE */
2706 #ifdef TC_SYMFIELD_TYPE
2708 /* Get a pointer to the processor information for a symbol. */
2710 TC_SYMFIELD_TYPE *
2711 symbol_get_tc (symbolS *s)
2713 if (LOCAL_SYMBOL_CHECK (s))
2714 s = local_symbol_convert ((struct local_symbol *) s);
2715 return &s->sy_tc;
2718 /* Set the processor information for a symbol. */
2720 void
2721 symbol_set_tc (symbolS *s, TC_SYMFIELD_TYPE *o)
2723 if (LOCAL_SYMBOL_CHECK (s))
2724 s = local_symbol_convert ((struct local_symbol *) s);
2725 s->sy_tc = *o;
2728 #endif /* TC_SYMFIELD_TYPE */
2730 void
2731 symbol_begin (void)
2733 symbol_lastP = NULL;
2734 symbol_rootP = NULL; /* In case we have 0 symbols (!!) */
2735 sy_hash = hash_new ();
2736 local_hash = hash_new ();
2738 memset ((char *) (&abs_symbol), '\0', sizeof (abs_symbol));
2739 #if defined (EMIT_SECTION_SYMBOLS) || !defined (RELOC_REQUIRES_SYMBOL)
2740 abs_symbol.bsym = bfd_abs_section.symbol;
2741 #endif
2742 abs_symbol.sy_value.X_op = O_constant;
2743 abs_symbol.sy_frag = &zero_address_frag;
2745 if (LOCAL_LABELS_FB)
2746 fb_label_init ();
2749 int indent_level;
2751 /* Maximum indent level.
2752 Available for modification inside a gdb session. */
2753 static int max_indent_level = 8;
2755 void
2756 print_symbol_value_1 (FILE *file, symbolS *sym)
2758 const char *name = S_GET_NAME (sym);
2759 if (!name || !name[0])
2760 name = "(unnamed)";
2761 fprintf (file, "sym ");
2762 fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) sym));
2763 fprintf (file, " %s", name);
2765 if (LOCAL_SYMBOL_CHECK (sym))
2767 struct local_symbol *locsym = (struct local_symbol *) sym;
2769 if (local_symbol_get_frag (locsym) != & zero_address_frag
2770 && local_symbol_get_frag (locsym) != NULL)
2772 fprintf (file, " frag ");
2773 fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) local_symbol_get_frag (locsym)));
2775 if (local_symbol_resolved_p (locsym))
2776 fprintf (file, " resolved");
2777 fprintf (file, " local");
2779 else
2781 if (sym->sy_frag != &zero_address_frag)
2783 fprintf (file, " frag ");
2784 fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) sym->sy_frag));
2786 if (sym->written)
2787 fprintf (file, " written");
2788 if (sym->sy_resolved)
2789 fprintf (file, " resolved");
2790 else if (sym->sy_resolving)
2791 fprintf (file, " resolving");
2792 if (sym->sy_used_in_reloc)
2793 fprintf (file, " used-in-reloc");
2794 if (sym->sy_used)
2795 fprintf (file, " used");
2796 if (S_IS_LOCAL (sym))
2797 fprintf (file, " local");
2798 if (S_IS_EXTERNAL (sym))
2799 fprintf (file, " extern");
2800 if (S_IS_WEAK (sym))
2801 fprintf (file, " weak");
2802 if (S_IS_DEBUG (sym))
2803 fprintf (file, " debug");
2804 if (S_IS_DEFINED (sym))
2805 fprintf (file, " defined");
2807 if (S_IS_WEAKREFR (sym))
2808 fprintf (file, " weakrefr");
2809 if (S_IS_WEAKREFD (sym))
2810 fprintf (file, " weakrefd");
2811 fprintf (file, " %s", segment_name (S_GET_SEGMENT (sym)));
2812 if (symbol_resolved_p (sym))
2814 segT s = S_GET_SEGMENT (sym);
2816 if (s != undefined_section
2817 && s != expr_section)
2818 fprintf (file, " %lx", (unsigned long) S_GET_VALUE (sym));
2820 else if (indent_level < max_indent_level
2821 && S_GET_SEGMENT (sym) != undefined_section)
2823 indent_level++;
2824 fprintf (file, "\n%*s<", indent_level * 4, "");
2825 if (LOCAL_SYMBOL_CHECK (sym))
2826 fprintf (file, "constant %lx",
2827 (unsigned long) ((struct local_symbol *) sym)->lsy_value);
2828 else
2829 print_expr_1 (file, &sym->sy_value);
2830 fprintf (file, ">");
2831 indent_level--;
2833 fflush (file);
2836 void
2837 print_symbol_value (symbolS *sym)
2839 indent_level = 0;
2840 print_symbol_value_1 (stderr, sym);
2841 fprintf (stderr, "\n");
2844 static void
2845 print_binary (FILE *file, const char *name, expressionS *exp)
2847 indent_level++;
2848 fprintf (file, "%s\n%*s<", name, indent_level * 4, "");
2849 print_symbol_value_1 (file, exp->X_add_symbol);
2850 fprintf (file, ">\n%*s<", indent_level * 4, "");
2851 print_symbol_value_1 (file, exp->X_op_symbol);
2852 fprintf (file, ">");
2853 indent_level--;
2856 void
2857 print_expr_1 (FILE *file, expressionS *exp)
2859 fprintf (file, "expr ");
2860 fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) exp));
2861 fprintf (file, " ");
2862 switch (exp->X_op)
2864 case O_illegal:
2865 fprintf (file, "illegal");
2866 break;
2867 case O_absent:
2868 fprintf (file, "absent");
2869 break;
2870 case O_constant:
2871 fprintf (file, "constant %lx", (unsigned long) exp->X_add_number);
2872 break;
2873 case O_symbol:
2874 indent_level++;
2875 fprintf (file, "symbol\n%*s<", indent_level * 4, "");
2876 print_symbol_value_1 (file, exp->X_add_symbol);
2877 fprintf (file, ">");
2878 maybe_print_addnum:
2879 if (exp->X_add_number)
2880 fprintf (file, "\n%*s%lx", indent_level * 4, "",
2881 (unsigned long) exp->X_add_number);
2882 indent_level--;
2883 break;
2884 case O_register:
2885 fprintf (file, "register #%d", (int) exp->X_add_number);
2886 break;
2887 case O_big:
2888 fprintf (file, "big");
2889 break;
2890 case O_uminus:
2891 fprintf (file, "uminus -<");
2892 indent_level++;
2893 print_symbol_value_1 (file, exp->X_add_symbol);
2894 fprintf (file, ">");
2895 goto maybe_print_addnum;
2896 case O_bit_not:
2897 fprintf (file, "bit_not");
2898 break;
2899 case O_multiply:
2900 print_binary (file, "multiply", exp);
2901 break;
2902 case O_divide:
2903 print_binary (file, "divide", exp);
2904 break;
2905 case O_modulus:
2906 print_binary (file, "modulus", exp);
2907 break;
2908 case O_left_shift:
2909 print_binary (file, "lshift", exp);
2910 break;
2911 case O_right_shift:
2912 print_binary (file, "rshift", exp);
2913 break;
2914 case O_bit_inclusive_or:
2915 print_binary (file, "bit_ior", exp);
2916 break;
2917 case O_bit_exclusive_or:
2918 print_binary (file, "bit_xor", exp);
2919 break;
2920 case O_bit_and:
2921 print_binary (file, "bit_and", exp);
2922 break;
2923 case O_eq:
2924 print_binary (file, "eq", exp);
2925 break;
2926 case O_ne:
2927 print_binary (file, "ne", exp);
2928 break;
2929 case O_lt:
2930 print_binary (file, "lt", exp);
2931 break;
2932 case O_le:
2933 print_binary (file, "le", exp);
2934 break;
2935 case O_ge:
2936 print_binary (file, "ge", exp);
2937 break;
2938 case O_gt:
2939 print_binary (file, "gt", exp);
2940 break;
2941 case O_logical_and:
2942 print_binary (file, "logical_and", exp);
2943 break;
2944 case O_logical_or:
2945 print_binary (file, "logical_or", exp);
2946 break;
2947 case O_add:
2948 indent_level++;
2949 fprintf (file, "add\n%*s<", indent_level * 4, "");
2950 print_symbol_value_1 (file, exp->X_add_symbol);
2951 fprintf (file, ">\n%*s<", indent_level * 4, "");
2952 print_symbol_value_1 (file, exp->X_op_symbol);
2953 fprintf (file, ">");
2954 goto maybe_print_addnum;
2955 case O_subtract:
2956 indent_level++;
2957 fprintf (file, "subtract\n%*s<", indent_level * 4, "");
2958 print_symbol_value_1 (file, exp->X_add_symbol);
2959 fprintf (file, ">\n%*s<", indent_level * 4, "");
2960 print_symbol_value_1 (file, exp->X_op_symbol);
2961 fprintf (file, ">");
2962 goto maybe_print_addnum;
2963 default:
2964 fprintf (file, "{unknown opcode %d}", (int) exp->X_op);
2965 break;
2967 fflush (stdout);
2970 void
2971 print_expr (expressionS *exp)
2973 print_expr_1 (stderr, exp);
2974 fprintf (stderr, "\n");
2977 void
2978 symbol_print_statistics (FILE *file)
2980 hash_print_statistics (file, "symbol table", sy_hash);
2981 hash_print_statistics (file, "mini local symbol table", local_hash);
2982 fprintf (file, "%lu mini local symbols created, %lu converted\n",
2983 local_symbol_count, local_symbol_conversion_count);
2986 #ifdef OBJ_COMPLEX_RELC
2988 /* Convert given symbol to a new complex-relocation symbol name. This
2989 may be a recursive function, since it might be called for non-leaf
2990 nodes (plain symbols) in the expression tree. The caller owns the
2991 returning string, so should free it eventually. Errors are
2992 indicated via as_bad and a NULL return value. The given symbol
2993 is marked with sy_used_in_reloc. */
2995 char *
2996 symbol_relc_make_sym (symbolS * sym)
2998 char * terminal = NULL;
2999 const char * sname;
3000 char typetag;
3001 int sname_len;
3003 gas_assert (sym != NULL);
3005 /* Recurse to symbol_relc_make_expr if this symbol
3006 is defined as an expression or a plain value. */
3007 if ( S_GET_SEGMENT (sym) == expr_section
3008 || S_GET_SEGMENT (sym) == absolute_section)
3009 return symbol_relc_make_expr (& sym->sy_value);
3011 /* This may be a "fake symbol" L0\001, referring to ".".
3012 Write out a special null symbol to refer to this position. */
3013 if (! strcmp (S_GET_NAME (sym), FAKE_LABEL_NAME))
3014 return xstrdup (".");
3016 /* We hope this is a plain leaf symbol. Construct the encoding
3017 as {S,s}II...:CCCCCCC....
3018 where 'S'/'s' means section symbol / plain symbol
3019 III is decimal for the symbol name length
3020 CCC is the symbol name itself. */
3021 symbol_mark_used_in_reloc (sym);
3023 sname = S_GET_NAME (sym);
3024 sname_len = strlen (sname);
3025 typetag = symbol_section_p (sym) ? 'S' : 's';
3027 terminal = xmalloc (1 /* S or s */
3028 + 8 /* sname_len in decimal */
3029 + 1 /* _ spacer */
3030 + sname_len /* name itself */
3031 + 1 /* \0 */ );
3033 sprintf (terminal, "%c%d:%s", typetag, sname_len, sname);
3034 return terminal;
3037 /* Convert given value to a new complex-relocation symbol name. This
3038 is a non-recursive function, since it is be called for leaf nodes
3039 (plain values) in the expression tree. The caller owns the
3040 returning string, so should free() it eventually. No errors. */
3042 char *
3043 symbol_relc_make_value (offsetT val)
3045 char * terminal = xmalloc (28); /* Enough for long long. */
3047 terminal[0] = '#';
3048 bfd_sprintf_vma (stdoutput, terminal + 1, val);
3049 return terminal;
3052 /* Convert given expression to a new complex-relocation symbol name.
3053 This is a recursive function, since it traverses the entire given
3054 expression tree. The caller owns the returning string, so should
3055 free() it eventually. Errors are indicated via as_bad() and a NULL
3056 return value. */
3058 char *
3059 symbol_relc_make_expr (expressionS * exp)
3061 char * opstr = NULL; /* Operator prefix string. */
3062 int arity = 0; /* Arity of this operator. */
3063 char * operands[3]; /* Up to three operands. */
3064 char * concat_string = NULL;
3066 operands[0] = operands[1] = operands[2] = NULL;
3068 gas_assert (exp != NULL);
3070 /* Match known operators -> fill in opstr, arity, operands[] and fall
3071 through to construct subexpression fragments; may instead return
3072 string directly for leaf nodes. */
3074 /* See expr.h for the meaning of all these enums. Many operators
3075 have an unnatural arity (X_add_number implicitly added). The
3076 conversion logic expands them to explicit "+" subexpressions. */
3078 switch (exp->X_op)
3080 default:
3081 as_bad ("Unknown expression operator (enum %d)", exp->X_op);
3082 break;
3084 /* Leaf nodes. */
3085 case O_constant:
3086 return symbol_relc_make_value (exp->X_add_number);
3088 case O_symbol:
3089 if (exp->X_add_number)
3091 arity = 2;
3092 opstr = "+";
3093 operands[0] = symbol_relc_make_sym (exp->X_add_symbol);
3094 operands[1] = symbol_relc_make_value (exp->X_add_number);
3095 break;
3097 else
3098 return symbol_relc_make_sym (exp->X_add_symbol);
3100 /* Helper macros for nesting nodes. */
3102 #define HANDLE_XADD_OPT1(str_) \
3103 if (exp->X_add_number) \
3105 arity = 2; \
3106 opstr = "+:" str_; \
3107 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3108 operands[1] = symbol_relc_make_value (exp->X_add_number); \
3109 break; \
3111 else \
3113 arity = 1; \
3114 opstr = str_; \
3115 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3117 break
3119 #define HANDLE_XADD_OPT2(str_) \
3120 if (exp->X_add_number) \
3122 arity = 3; \
3123 opstr = "+:" str_; \
3124 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3125 operands[1] = symbol_relc_make_sym (exp->X_op_symbol); \
3126 operands[2] = symbol_relc_make_value (exp->X_add_number); \
3128 else \
3130 arity = 2; \
3131 opstr = str_; \
3132 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3133 operands[1] = symbol_relc_make_sym (exp->X_op_symbol); \
3135 break
3137 /* Nesting nodes. */
3139 case O_uminus: HANDLE_XADD_OPT1 ("0-");
3140 case O_bit_not: HANDLE_XADD_OPT1 ("~");
3141 case O_logical_not: HANDLE_XADD_OPT1 ("!");
3142 case O_multiply: HANDLE_XADD_OPT2 ("*");
3143 case O_divide: HANDLE_XADD_OPT2 ("/");
3144 case O_modulus: HANDLE_XADD_OPT2 ("%");
3145 case O_left_shift: HANDLE_XADD_OPT2 ("<<");
3146 case O_right_shift: HANDLE_XADD_OPT2 (">>");
3147 case O_bit_inclusive_or: HANDLE_XADD_OPT2 ("|");
3148 case O_bit_exclusive_or: HANDLE_XADD_OPT2 ("^");
3149 case O_bit_and: HANDLE_XADD_OPT2 ("&");
3150 case O_add: HANDLE_XADD_OPT2 ("+");
3151 case O_subtract: HANDLE_XADD_OPT2 ("-");
3152 case O_eq: HANDLE_XADD_OPT2 ("==");
3153 case O_ne: HANDLE_XADD_OPT2 ("!=");
3154 case O_lt: HANDLE_XADD_OPT2 ("<");
3155 case O_le: HANDLE_XADD_OPT2 ("<=");
3156 case O_ge: HANDLE_XADD_OPT2 (">=");
3157 case O_gt: HANDLE_XADD_OPT2 (">");
3158 case O_logical_and: HANDLE_XADD_OPT2 ("&&");
3159 case O_logical_or: HANDLE_XADD_OPT2 ("||");
3162 /* Validate & reject early. */
3163 if (arity >= 1 && ((operands[0] == NULL) || (strlen (operands[0]) == 0)))
3164 opstr = NULL;
3165 if (arity >= 2 && ((operands[1] == NULL) || (strlen (operands[1]) == 0)))
3166 opstr = NULL;
3167 if (arity >= 3 && ((operands[2] == NULL) || (strlen (operands[2]) == 0)))
3168 opstr = NULL;
3170 if (opstr == NULL)
3171 concat_string = NULL;
3172 else
3174 /* Allocate new string; include inter-operand padding gaps etc. */
3175 concat_string = xmalloc (strlen (opstr)
3177 + (arity >= 1 ? (strlen (operands[0]) + 1 ) : 0)
3178 + (arity >= 2 ? (strlen (operands[1]) + 1 ) : 0)
3179 + (arity >= 3 ? (strlen (operands[2]) + 0 ) : 0)
3180 + 1);
3181 gas_assert (concat_string != NULL);
3183 /* Format the thing. */
3184 sprintf (concat_string,
3185 (arity == 0 ? "%s" :
3186 arity == 1 ? "%s:%s" :
3187 arity == 2 ? "%s:%s:%s" :
3188 /* arity == 3 */ "%s:%s:%s:%s"),
3189 opstr, operands[0], operands[1], operands[2]);
3192 /* Free operand strings (not opstr). */
3193 if (arity >= 1) xfree (operands[0]);
3194 if (arity >= 2) xfree (operands[1]);
3195 if (arity >= 3) xfree (operands[2]);
3197 return concat_string;
3200 #endif