daily update
[binutils.git] / gas / symbols.c
blob660b2a4f1449dc70bd147646faa47cd5e1aa16de
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
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 USE_UNIQUE
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 = 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 = 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 value, fragS *frag)
193 char *name_copy;
194 struct local_symbol *ret;
196 ++local_symbol_count;
198 name_copy = save_symbol_name (name);
200 ret = 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 = value;
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 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 /* We have just seen "<name>:".
250 Creates a struct symbol unless it already exists.
252 Gripes if we are redefining a symbol incompatibly (and ignores it). */
254 symbolS *
255 colon (/* Just seen "x:" - rattle symbols & frags. */
256 const char *sym_name /* Symbol name, as a cannonical string. */
257 /* We copy this string: OK to alter later. */)
259 register symbolS *symbolP; /* Symbol we are working with. */
261 /* Sun local labels go out of scope whenever a non-local symbol is
262 defined. */
263 if (LOCAL_LABELS_DOLLAR
264 && !bfd_is_local_label_name (stdoutput, sym_name))
265 dollar_label_clear ();
267 #ifndef WORKING_DOT_WORD
268 if (new_broken_words)
270 struct broken_word *a;
271 int possible_bytes;
272 fragS *frag_tmp;
273 char *frag_opcode;
275 if (now_seg == absolute_section)
277 as_bad (_("cannot define symbol `%s' in absolute section"), sym_name);
278 return NULL;
281 possible_bytes = (md_short_jump_size
282 + new_broken_words * md_long_jump_size);
284 frag_tmp = frag_now;
285 frag_opcode = frag_var (rs_broken_word,
286 possible_bytes,
287 possible_bytes,
288 (relax_substateT) 0,
289 (symbolS *) broken_words,
290 (offsetT) 0,
291 NULL);
293 /* We want to store the pointer to where to insert the jump
294 table in the fr_opcode of the rs_broken_word frag. This
295 requires a little hackery. */
296 while (frag_tmp
297 && (frag_tmp->fr_type != rs_broken_word
298 || frag_tmp->fr_opcode))
299 frag_tmp = frag_tmp->fr_next;
300 know (frag_tmp);
301 frag_tmp->fr_opcode = frag_opcode;
302 new_broken_words = 0;
304 for (a = broken_words; a && a->dispfrag == 0; a = a->next_broken_word)
305 a->dispfrag = frag_tmp;
307 #endif /* WORKING_DOT_WORD */
309 if ((symbolP = symbol_find (sym_name)) != 0)
311 S_CLEAR_WEAKREFR (symbolP);
312 #ifdef RESOLVE_SYMBOL_REDEFINITION
313 if (RESOLVE_SYMBOL_REDEFINITION (symbolP))
314 return symbolP;
315 #endif
316 /* Now check for undefined symbols. */
317 if (LOCAL_SYMBOL_CHECK (symbolP))
319 struct local_symbol *locsym = (struct local_symbol *) symbolP;
321 if (locsym->lsy_section != undefined_section
322 && (local_symbol_get_frag (locsym) != frag_now
323 || locsym->lsy_section != now_seg
324 || locsym->lsy_value != frag_now_fix ()))
326 as_bad (_("symbol `%s' is already defined"), sym_name);
327 return symbolP;
330 locsym->lsy_section = now_seg;
331 local_symbol_set_frag (locsym, frag_now);
332 locsym->lsy_value = frag_now_fix ();
334 else if (!(S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
335 || S_IS_COMMON (symbolP)
336 || S_IS_VOLATILE (symbolP))
338 if (S_IS_VOLATILE (symbolP))
340 symbolP = symbol_clone (symbolP, 1);
341 S_SET_VALUE (symbolP, 0);
342 S_CLEAR_VOLATILE (symbolP);
344 if (S_GET_VALUE (symbolP) == 0)
346 symbolP->sy_frag = frag_now;
347 #ifdef OBJ_VMS
348 S_SET_OTHER (symbolP, const_flag);
349 #endif
350 S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
351 S_SET_SEGMENT (symbolP, now_seg);
352 #ifdef N_UNDF
353 know (N_UNDF == 0);
354 #endif /* if we have one, it better be zero. */
357 else
359 /* There are still several cases to check:
361 A .comm/.lcomm symbol being redefined as initialized
362 data is OK
364 A .comm/.lcomm symbol being redefined with a larger
365 size is also OK
367 This only used to be allowed on VMS gas, but Sun cc
368 on the sparc also depends on it. */
370 if (((!S_IS_DEBUG (symbolP)
371 && (!S_IS_DEFINED (symbolP) || S_IS_COMMON (symbolP))
372 && S_IS_EXTERNAL (symbolP))
373 || S_GET_SEGMENT (symbolP) == bss_section)
374 && (now_seg == data_section
375 || now_seg == bss_section
376 || now_seg == S_GET_SEGMENT (symbolP)))
378 /* Select which of the 2 cases this is. */
379 if (now_seg != data_section)
381 /* New .comm for prev .comm symbol.
383 If the new size is larger we just change its
384 value. If the new size is smaller, we ignore
385 this symbol. */
386 if (S_GET_VALUE (symbolP)
387 < ((unsigned) frag_now_fix ()))
389 S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
392 else
394 /* It is a .comm/.lcomm being converted to initialized
395 data. */
396 symbolP->sy_frag = frag_now;
397 #ifdef OBJ_VMS
398 S_SET_OTHER (symbolP, const_flag);
399 #endif
400 S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
401 S_SET_SEGMENT (symbolP, now_seg); /* Keep N_EXT bit. */
404 else
406 #if (!defined (OBJ_AOUT) && !defined (OBJ_MAYBE_AOUT) \
407 && !defined (OBJ_BOUT) && !defined (OBJ_MAYBE_BOUT))
408 static const char *od_buf = "";
409 #else
410 char od_buf[100];
411 od_buf[0] = '\0';
412 if (OUTPUT_FLAVOR == bfd_target_aout_flavour)
413 sprintf (od_buf, "%d.%d.",
414 S_GET_OTHER (symbolP),
415 S_GET_DESC (symbolP));
416 #endif
417 as_bad (_("symbol `%s' is already defined as \"%s\"/%s%ld"),
418 sym_name,
419 segment_name (S_GET_SEGMENT (symbolP)),
420 od_buf,
421 (long) S_GET_VALUE (symbolP));
423 } /* if the undefined symbol has no value */
425 else
427 /* Don't blow up if the definition is the same. */
428 if (!(frag_now == symbolP->sy_frag
429 && S_GET_VALUE (symbolP) == frag_now_fix ()
430 && S_GET_SEGMENT (symbolP) == now_seg))
432 as_bad (_("symbol `%s' is already defined"), sym_name);
433 symbolP = symbol_clone (symbolP, 0);
438 else if (! flag_keep_locals && bfd_is_local_label_name (stdoutput, sym_name))
440 symbolP = (symbolS *) local_symbol_make (sym_name, now_seg,
441 (valueT) frag_now_fix (),
442 frag_now);
444 else
446 symbolP = symbol_new (sym_name, now_seg, (valueT) frag_now_fix (),
447 frag_now);
448 #ifdef OBJ_VMS
449 S_SET_OTHER (symbolP, const_flag);
450 #endif /* OBJ_VMS */
452 symbol_table_insert (symbolP);
455 if (mri_common_symbol != NULL)
457 /* This symbol is actually being defined within an MRI common
458 section. This requires special handling. */
459 if (LOCAL_SYMBOL_CHECK (symbolP))
460 symbolP = local_symbol_convert ((struct local_symbol *) symbolP);
461 symbolP->sy_value.X_op = O_symbol;
462 symbolP->sy_value.X_add_symbol = mri_common_symbol;
463 symbolP->sy_value.X_add_number = S_GET_VALUE (mri_common_symbol);
464 symbolP->sy_frag = &zero_address_frag;
465 S_SET_SEGMENT (symbolP, expr_section);
466 symbolP->sy_mri_common = 1;
469 #ifdef tc_frob_label
470 tc_frob_label (symbolP);
471 #endif
472 #ifdef obj_frob_label
473 obj_frob_label (symbolP);
474 #endif
476 return symbolP;
479 /* Die if we can't insert the symbol. */
481 void
482 symbol_table_insert (symbolS *symbolP)
484 register const char *error_string;
486 know (symbolP);
487 know (S_GET_NAME (symbolP));
489 if (LOCAL_SYMBOL_CHECK (symbolP))
491 error_string = hash_jam (local_hash, S_GET_NAME (symbolP),
492 (void *) symbolP);
493 if (error_string != NULL)
494 as_fatal (_("inserting \"%s\" into symbol table failed: %s"),
495 S_GET_NAME (symbolP), error_string);
496 return;
499 if ((error_string = hash_jam (sy_hash, S_GET_NAME (symbolP), (void *) symbolP)))
501 as_fatal (_("inserting \"%s\" into symbol table failed: %s"),
502 S_GET_NAME (symbolP), error_string);
503 } /* on error */
506 /* If a symbol name does not exist, create it as undefined, and insert
507 it into the symbol table. Return a pointer to it. */
509 symbolS *
510 symbol_find_or_make (const char *name)
512 register symbolS *symbolP;
514 symbolP = symbol_find (name);
516 if (symbolP == NULL)
518 if (! flag_keep_locals && bfd_is_local_label_name (stdoutput, name))
520 symbolP = md_undefined_symbol ((char *) name);
521 if (symbolP != NULL)
522 return symbolP;
524 symbolP = (symbolS *) local_symbol_make (name, undefined_section,
525 (valueT) 0,
526 &zero_address_frag);
527 return symbolP;
530 symbolP = symbol_make (name);
532 symbol_table_insert (symbolP);
533 } /* if symbol wasn't found */
535 return (symbolP);
538 symbolS *
539 symbol_make (const char *name)
541 symbolS *symbolP;
543 /* Let the machine description default it, e.g. for register names. */
544 symbolP = md_undefined_symbol ((char *) name);
546 if (!symbolP)
547 symbolP = symbol_new (name, undefined_section, (valueT) 0, &zero_address_frag);
549 return (symbolP);
552 symbolS *
553 symbol_clone (symbolS *orgsymP, int replace)
555 symbolS *newsymP;
556 asymbol *bsymorg, *bsymnew;
558 /* Running local_symbol_convert on a clone that's not the one currently
559 in local_hash would incorrectly replace the hash entry. Thus the
560 symbol must be converted here. Note that the rest of the function
561 depends on not encountering an unconverted symbol. */
562 if (LOCAL_SYMBOL_CHECK (orgsymP))
563 orgsymP = local_symbol_convert ((struct local_symbol *) orgsymP);
564 bsymorg = orgsymP->bsym;
566 newsymP = obstack_alloc (&notes, sizeof (*newsymP));
567 *newsymP = *orgsymP;
568 bsymnew = bfd_make_empty_symbol (bfd_asymbol_bfd (bsymorg));
569 if (bsymnew == NULL)
570 as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));
571 newsymP->bsym = bsymnew;
572 bsymnew->name = bsymorg->name;
573 bsymnew->flags = bsymorg->flags;
574 bsymnew->section = bsymorg->section;
575 bfd_copy_private_symbol_data (bfd_asymbol_bfd (bsymorg), bsymorg,
576 bfd_asymbol_bfd (bsymnew), bsymnew);
578 #ifdef obj_symbol_clone_hook
579 obj_symbol_clone_hook (newsymP, orgsymP);
580 #endif
582 #ifdef tc_symbol_clone_hook
583 tc_symbol_clone_hook (newsymP, orgsymP);
584 #endif
586 if (replace)
588 if (symbol_rootP == orgsymP)
589 symbol_rootP = newsymP;
590 else if (orgsymP->sy_previous)
592 orgsymP->sy_previous->sy_next = newsymP;
593 orgsymP->sy_previous = NULL;
595 if (symbol_lastP == orgsymP)
596 symbol_lastP = newsymP;
597 else if (orgsymP->sy_next)
598 orgsymP->sy_next->sy_previous = newsymP;
600 /* Symbols that won't be output can't be external. */
601 S_CLEAR_EXTERNAL (orgsymP);
602 orgsymP->sy_previous = orgsymP->sy_next = orgsymP;
603 debug_verify_symchain (symbol_rootP, symbol_lastP);
605 symbol_table_insert (newsymP);
607 else
609 /* Symbols that won't be output can't be external. */
610 S_CLEAR_EXTERNAL (newsymP);
611 newsymP->sy_previous = newsymP->sy_next = newsymP;
614 return newsymP;
617 /* Referenced symbols, if they are forward references, need to be cloned
618 (without replacing the original) so that the value of the referenced
619 symbols at the point of use . */
621 #undef symbol_clone_if_forward_ref
622 symbolS *
623 symbol_clone_if_forward_ref (symbolS *symbolP, int is_forward)
625 if (symbolP && !LOCAL_SYMBOL_CHECK (symbolP))
627 symbolS *add_symbol = symbolP->sy_value.X_add_symbol;
628 symbolS *op_symbol = symbolP->sy_value.X_op_symbol;
630 if (symbolP->sy_forward_ref)
631 is_forward = 1;
633 if (is_forward)
635 /* assign_symbol() clones volatile symbols; pre-existing expressions
636 hold references to the original instance, but want the current
637 value. Just repeat the lookup. */
638 if (add_symbol && S_IS_VOLATILE (add_symbol))
639 add_symbol = symbol_find_exact (S_GET_NAME (add_symbol));
640 if (op_symbol && S_IS_VOLATILE (op_symbol))
641 op_symbol = symbol_find_exact (S_GET_NAME (op_symbol));
644 /* Re-using sy_resolving here, as this routine cannot get called from
645 symbol resolution code. */
646 if (symbolP->bsym->section == expr_section && !symbolP->sy_resolving)
648 symbolP->sy_resolving = 1;
649 add_symbol = symbol_clone_if_forward_ref (add_symbol, is_forward);
650 op_symbol = symbol_clone_if_forward_ref (op_symbol, is_forward);
651 symbolP->sy_resolving = 0;
654 if (symbolP->sy_forward_ref
655 || add_symbol != symbolP->sy_value.X_add_symbol
656 || op_symbol != symbolP->sy_value.X_op_symbol)
657 symbolP = symbol_clone (symbolP, 0);
659 symbolP->sy_value.X_add_symbol = add_symbol;
660 symbolP->sy_value.X_op_symbol = op_symbol;
663 return symbolP;
666 symbolS *
667 symbol_temp_new (segT seg, valueT ofs, fragS *frag)
669 return symbol_new (FAKE_LABEL_NAME, seg, ofs, frag);
672 symbolS *
673 symbol_temp_new_now (void)
675 return symbol_temp_new (now_seg, frag_now_fix (), frag_now);
678 symbolS *
679 symbol_temp_make (void)
681 return symbol_make (FAKE_LABEL_NAME);
684 /* Implement symbol table lookup.
685 In: A symbol's name as a string: '\0' can't be part of a symbol name.
686 Out: NULL if the name was not in the symbol table, else the address
687 of a struct symbol associated with that name. */
689 symbolS *
690 symbol_find_exact (const char *name)
692 return symbol_find_exact_noref (name, 0);
695 symbolS *
696 symbol_find_exact_noref (const char *name, int noref)
698 struct local_symbol *locsym;
699 symbolS* sym;
701 locsym = (struct local_symbol *) hash_find (local_hash, name);
702 if (locsym != NULL)
703 return (symbolS *) locsym;
705 sym = ((symbolS *) hash_find (sy_hash, name));
707 /* Any references to the symbol, except for the reference in
708 .weakref, must clear this flag, such that the symbol does not
709 turn into a weak symbol. Note that we don't have to handle the
710 local_symbol case, since a weakrefd is always promoted out of the
711 local_symbol table when it is turned into a weak symbol. */
712 if (sym && ! noref)
713 S_CLEAR_WEAKREFD (sym);
715 return sym;
718 symbolS *
719 symbol_find (const char *name)
721 return symbol_find_noref (name, 0);
724 symbolS *
725 symbol_find_noref (const char *name, int noref)
727 #ifdef tc_canonicalize_symbol_name
729 char *copy;
730 size_t len = strlen (name) + 1;
732 copy = (char *) alloca (len);
733 memcpy (copy, name, len);
734 name = tc_canonicalize_symbol_name (copy);
736 #endif
738 if (! symbols_case_sensitive)
740 char *copy;
741 const char *orig;
742 unsigned char c;
744 orig = name;
745 name = copy = (char *) alloca (strlen (name) + 1);
747 while ((c = *orig++) != '\0')
749 *copy++ = TOUPPER (c);
751 *copy = '\0';
754 return symbol_find_exact_noref (name, noref);
757 /* Once upon a time, symbols were kept in a singly linked list. At
758 least coff needs to be able to rearrange them from time to time, for
759 which a doubly linked list is much more convenient. Loic did these
760 as macros which seemed dangerous to me so they're now functions.
761 xoxorich. */
763 /* Link symbol ADDME after symbol TARGET in the chain. */
765 void
766 symbol_append (symbolS *addme, symbolS *target,
767 symbolS **rootPP, symbolS **lastPP)
769 if (LOCAL_SYMBOL_CHECK (addme))
770 abort ();
771 if (target != NULL && LOCAL_SYMBOL_CHECK (target))
772 abort ();
774 if (target == NULL)
776 know (*rootPP == NULL);
777 know (*lastPP == NULL);
778 addme->sy_next = NULL;
779 addme->sy_previous = NULL;
780 *rootPP = addme;
781 *lastPP = addme;
782 return;
783 } /* if the list is empty */
785 if (target->sy_next != NULL)
787 target->sy_next->sy_previous = addme;
789 else
791 know (*lastPP == target);
792 *lastPP = addme;
793 } /* if we have a next */
795 addme->sy_next = target->sy_next;
796 target->sy_next = addme;
797 addme->sy_previous = target;
799 debug_verify_symchain (symbol_rootP, symbol_lastP);
802 /* Set the chain pointers of SYMBOL to null. */
804 void
805 symbol_clear_list_pointers (symbolS *symbolP)
807 if (LOCAL_SYMBOL_CHECK (symbolP))
808 abort ();
809 symbolP->sy_next = NULL;
810 symbolP->sy_previous = NULL;
813 /* Remove SYMBOLP from the list. */
815 void
816 symbol_remove (symbolS *symbolP, symbolS **rootPP, symbolS **lastPP)
818 if (LOCAL_SYMBOL_CHECK (symbolP))
819 abort ();
821 if (symbolP == *rootPP)
823 *rootPP = symbolP->sy_next;
824 } /* if it was the root */
826 if (symbolP == *lastPP)
828 *lastPP = symbolP->sy_previous;
829 } /* if it was the tail */
831 if (symbolP->sy_next != NULL)
833 symbolP->sy_next->sy_previous = symbolP->sy_previous;
834 } /* if not last */
836 if (symbolP->sy_previous != NULL)
838 symbolP->sy_previous->sy_next = symbolP->sy_next;
839 } /* if not first */
841 debug_verify_symchain (*rootPP, *lastPP);
844 /* Link symbol ADDME before symbol TARGET in the chain. */
846 void
847 symbol_insert (symbolS *addme, symbolS *target,
848 symbolS **rootPP, symbolS **lastPP ATTRIBUTE_UNUSED)
850 if (LOCAL_SYMBOL_CHECK (addme))
851 abort ();
852 if (LOCAL_SYMBOL_CHECK (target))
853 abort ();
855 if (target->sy_previous != NULL)
857 target->sy_previous->sy_next = addme;
859 else
861 know (*rootPP == target);
862 *rootPP = addme;
863 } /* if not first */
865 addme->sy_previous = target->sy_previous;
866 target->sy_previous = addme;
867 addme->sy_next = target;
869 debug_verify_symchain (*rootPP, *lastPP);
872 void
873 verify_symbol_chain (symbolS *rootP, symbolS *lastP)
875 symbolS *symbolP = rootP;
877 if (symbolP == NULL)
878 return;
880 for (; symbol_next (symbolP) != NULL; symbolP = symbol_next (symbolP))
882 assert (symbolP->bsym != NULL);
883 assert (symbolP->sy_next->sy_previous == symbolP);
886 assert (lastP == symbolP);
889 #ifdef OBJ_COMPLEX_RELC
891 static int
892 use_complex_relocs_for (symbolS * symp)
894 switch (symp->sy_value.X_op)
896 case O_constant:
897 return 0;
899 case O_symbol:
900 case O_symbol_rva:
901 case O_uminus:
902 case O_bit_not:
903 case O_logical_not:
904 if ( (S_IS_COMMON (symp->sy_value.X_add_symbol)
905 || S_IS_LOCAL (symp->sy_value.X_add_symbol))
907 (S_IS_DEFINED (symp->sy_value.X_add_symbol)
908 && S_GET_SEGMENT (symp->sy_value.X_add_symbol) != expr_section))
909 return 0;
910 break;
912 case O_multiply:
913 case O_divide:
914 case O_modulus:
915 case O_left_shift:
916 case O_right_shift:
917 case O_bit_inclusive_or:
918 case O_bit_or_not:
919 case O_bit_exclusive_or:
920 case O_bit_and:
921 case O_add:
922 case O_subtract:
923 case O_eq:
924 case O_ne:
925 case O_lt:
926 case O_le:
927 case O_ge:
928 case O_gt:
929 case O_logical_and:
930 case O_logical_or:
932 if ( (S_IS_COMMON (symp->sy_value.X_add_symbol)
933 || S_IS_LOCAL (symp->sy_value.X_add_symbol))
935 (S_IS_COMMON (symp->sy_value.X_op_symbol)
936 || S_IS_LOCAL (symp->sy_value.X_op_symbol))
938 && S_IS_DEFINED (symp->sy_value.X_add_symbol)
939 && S_IS_DEFINED (symp->sy_value.X_op_symbol)
940 && S_GET_SEGMENT (symp->sy_value.X_add_symbol) != expr_section
941 && S_GET_SEGMENT (symp->sy_value.X_op_symbol) != expr_section)
942 return 0;
943 break;
945 default:
946 break;
948 return 1;
950 #endif
952 static void
953 report_op_error (symbolS *symp, symbolS *left, symbolS *right)
955 char *file;
956 unsigned int line;
957 segT seg_left = S_GET_SEGMENT (left);
958 segT seg_right = right ? S_GET_SEGMENT (right) : 0;
960 if (expr_symbol_where (symp, &file, &line))
962 if (seg_left == undefined_section)
963 as_bad_where (file, line,
964 _("undefined symbol `%s' in operation"),
965 S_GET_NAME (left));
966 if (seg_right == undefined_section)
967 as_bad_where (file, line,
968 _("undefined symbol `%s' in operation"),
969 S_GET_NAME (right));
970 if (seg_left != undefined_section
971 && seg_right != undefined_section)
973 if (right)
974 as_bad_where (file, line,
975 _("invalid sections for operation on `%s' and `%s'"),
976 S_GET_NAME (left), S_GET_NAME (right));
977 else
978 as_bad_where (file, line,
979 _("invalid section for operation on `%s'"),
980 S_GET_NAME (left));
984 else
986 if (seg_left == undefined_section)
987 as_bad (_("undefined symbol `%s' in operation setting `%s'"),
988 S_GET_NAME (left), S_GET_NAME (symp));
989 if (seg_right == undefined_section)
990 as_bad (_("undefined symbol `%s' in operation setting `%s'"),
991 S_GET_NAME (right), S_GET_NAME (symp));
992 if (seg_left != undefined_section
993 && seg_right != undefined_section)
995 if (right)
996 as_bad (_("invalid sections for operation on `%s' and `%s' setting `%s'"),
997 S_GET_NAME (left), S_GET_NAME (right), S_GET_NAME (symp));
998 else
999 as_bad (_("invalid section for operation on `%s' setting `%s'"),
1000 S_GET_NAME (left), S_GET_NAME (symp));
1005 /* Resolve the value of a symbol. This is called during the final
1006 pass over the symbol table to resolve any symbols with complex
1007 values. */
1009 valueT
1010 resolve_symbol_value (symbolS *symp)
1012 int resolved;
1013 valueT final_val = 0;
1014 segT final_seg;
1016 if (LOCAL_SYMBOL_CHECK (symp))
1018 struct local_symbol *locsym = (struct local_symbol *) symp;
1020 final_val = locsym->lsy_value;
1021 if (local_symbol_resolved_p (locsym))
1022 return final_val;
1024 final_val += local_symbol_get_frag (locsym)->fr_address / OCTETS_PER_BYTE;
1026 if (finalize_syms)
1028 locsym->lsy_value = final_val;
1029 local_symbol_mark_resolved (locsym);
1032 return final_val;
1035 if (symp->sy_resolved)
1037 if (symp->sy_value.X_op == O_constant)
1038 return (valueT) symp->sy_value.X_add_number;
1039 else
1040 return 0;
1043 resolved = 0;
1044 final_seg = S_GET_SEGMENT (symp);
1046 if (symp->sy_resolving)
1048 if (finalize_syms)
1049 as_bad (_("symbol definition loop encountered at `%s'"),
1050 S_GET_NAME (symp));
1051 final_val = 0;
1052 resolved = 1;
1054 #ifdef OBJ_COMPLEX_RELC
1055 else if (final_seg == expr_section
1056 && use_complex_relocs_for (symp))
1058 symbolS * relc_symbol = NULL;
1059 char * relc_symbol_name = NULL;
1061 relc_symbol_name = symbol_relc_make_expr (& symp->sy_value);
1063 /* For debugging, print out conversion input & output. */
1064 #ifdef DEBUG_SYMS
1065 print_expr (& symp->sy_value);
1066 if (relc_symbol_name)
1067 fprintf (stderr, "-> relc symbol: %s\n", relc_symbol_name);
1068 #endif
1070 if (relc_symbol_name != NULL)
1071 relc_symbol = symbol_new (relc_symbol_name, undefined_section,
1072 0, & zero_address_frag);
1074 if (relc_symbol == NULL)
1076 as_bad (_("cannot convert expression symbol %s to complex relocation"),
1077 S_GET_NAME (symp));
1078 resolved = 0;
1080 else
1082 symbol_table_insert (relc_symbol);
1084 /* S_CLEAR_EXTERNAL (relc_symbol); */
1085 if (symp->bsym->flags & BSF_SRELC)
1086 relc_symbol->bsym->flags |= BSF_SRELC;
1087 else
1088 relc_symbol->bsym->flags |= BSF_RELC;
1089 /* symp->bsym->flags |= BSF_RELC; */
1090 copy_symbol_attributes (symp, relc_symbol);
1091 symp->sy_value.X_op = O_symbol;
1092 symp->sy_value.X_add_symbol = relc_symbol;
1093 symp->sy_value.X_add_number = 0;
1094 resolved = 1;
1097 final_seg = undefined_section;
1098 goto exit_dont_set_value;
1100 #endif
1101 else
1103 symbolS *add_symbol, *op_symbol;
1104 offsetT left, right;
1105 segT seg_left, seg_right;
1106 operatorT op;
1107 int move_seg_ok;
1109 symp->sy_resolving = 1;
1111 /* Help out with CSE. */
1112 add_symbol = symp->sy_value.X_add_symbol;
1113 op_symbol = symp->sy_value.X_op_symbol;
1114 final_val = symp->sy_value.X_add_number;
1115 op = symp->sy_value.X_op;
1117 switch (op)
1119 default:
1120 BAD_CASE (op);
1121 break;
1123 case O_absent:
1124 final_val = 0;
1125 /* Fall through. */
1127 case O_constant:
1128 final_val += symp->sy_frag->fr_address / OCTETS_PER_BYTE;
1129 if (final_seg == expr_section)
1130 final_seg = absolute_section;
1131 /* Fall through. */
1133 case O_register:
1134 resolved = 1;
1135 break;
1137 case O_symbol:
1138 case O_symbol_rva:
1139 left = resolve_symbol_value (add_symbol);
1140 seg_left = S_GET_SEGMENT (add_symbol);
1141 if (finalize_syms)
1142 symp->sy_value.X_op_symbol = NULL;
1144 do_symbol:
1145 if (S_IS_WEAKREFR (symp))
1147 assert (final_val == 0);
1148 if (S_IS_WEAKREFR (add_symbol))
1150 assert (add_symbol->sy_value.X_op == O_symbol
1151 && add_symbol->sy_value.X_add_number == 0);
1152 add_symbol = add_symbol->sy_value.X_add_symbol;
1153 assert (! S_IS_WEAKREFR (add_symbol));
1154 symp->sy_value.X_add_symbol = add_symbol;
1158 if (symp->sy_mri_common)
1160 /* This is a symbol inside an MRI common section. The
1161 relocation routines are going to handle it specially.
1162 Don't change the value. */
1163 resolved = symbol_resolved_p (add_symbol);
1164 break;
1167 if (finalize_syms && final_val == 0)
1169 if (LOCAL_SYMBOL_CHECK (add_symbol))
1170 add_symbol = local_symbol_convert ((struct local_symbol *)
1171 add_symbol);
1172 copy_symbol_attributes (symp, add_symbol);
1175 /* If we have equated this symbol to an undefined or common
1176 symbol, keep X_op set to O_symbol, and don't change
1177 X_add_number. This permits the routine which writes out
1178 relocation to detect this case, and convert the
1179 relocation to be against the symbol to which this symbol
1180 is equated. */
1181 if (! S_IS_DEFINED (add_symbol)
1182 #if defined (OBJ_COFF) && defined (TE_PE)
1183 || S_IS_WEAK (add_symbol)
1184 #endif
1185 || S_IS_COMMON (add_symbol))
1187 if (finalize_syms)
1189 symp->sy_value.X_op = O_symbol;
1190 symp->sy_value.X_add_symbol = add_symbol;
1191 symp->sy_value.X_add_number = final_val;
1192 /* Use X_op_symbol as a flag. */
1193 symp->sy_value.X_op_symbol = add_symbol;
1194 final_seg = seg_left;
1196 final_val = 0;
1197 resolved = symbol_resolved_p (add_symbol);
1198 symp->sy_resolving = 0;
1199 goto exit_dont_set_value;
1201 else if (finalize_syms
1202 && ((final_seg == expr_section && seg_left != expr_section)
1203 || symbol_shadow_p (symp)))
1205 /* If the symbol is an expression symbol, do similarly
1206 as for undefined and common syms above. Handles
1207 "sym +/- expr" where "expr" cannot be evaluated
1208 immediately, and we want relocations to be against
1209 "sym", eg. because it is weak. */
1210 symp->sy_value.X_op = O_symbol;
1211 symp->sy_value.X_add_symbol = add_symbol;
1212 symp->sy_value.X_add_number = final_val;
1213 symp->sy_value.X_op_symbol = add_symbol;
1214 final_seg = seg_left;
1215 final_val += symp->sy_frag->fr_address + left;
1216 resolved = symbol_resolved_p (add_symbol);
1217 symp->sy_resolving = 0;
1218 goto exit_dont_set_value;
1220 else
1222 final_val += symp->sy_frag->fr_address + left;
1223 if (final_seg == expr_section || final_seg == undefined_section)
1224 final_seg = seg_left;
1227 resolved = symbol_resolved_p (add_symbol);
1228 if (S_IS_WEAKREFR (symp))
1229 goto exit_dont_set_value;
1230 break;
1232 case O_uminus:
1233 case O_bit_not:
1234 case O_logical_not:
1235 left = resolve_symbol_value (add_symbol);
1236 seg_left = S_GET_SEGMENT (add_symbol);
1238 /* By reducing these to the relevant dyadic operator, we get
1239 !S -> S == 0 permitted on anything,
1240 -S -> 0 - S only permitted on absolute
1241 ~S -> S ^ ~0 only permitted on absolute */
1242 if (op != O_logical_not && seg_left != absolute_section
1243 && finalize_syms)
1244 report_op_error (symp, add_symbol, NULL);
1246 if (final_seg == expr_section || final_seg == undefined_section)
1247 final_seg = absolute_section;
1249 if (op == O_uminus)
1250 left = -left;
1251 else if (op == O_logical_not)
1252 left = !left;
1253 else
1254 left = ~left;
1256 final_val += left + symp->sy_frag->fr_address;
1258 resolved = symbol_resolved_p (add_symbol);
1259 break;
1261 case O_multiply:
1262 case O_divide:
1263 case O_modulus:
1264 case O_left_shift:
1265 case O_right_shift:
1266 case O_bit_inclusive_or:
1267 case O_bit_or_not:
1268 case O_bit_exclusive_or:
1269 case O_bit_and:
1270 case O_add:
1271 case O_subtract:
1272 case O_eq:
1273 case O_ne:
1274 case O_lt:
1275 case O_le:
1276 case O_ge:
1277 case O_gt:
1278 case O_logical_and:
1279 case O_logical_or:
1280 left = resolve_symbol_value (add_symbol);
1281 right = resolve_symbol_value (op_symbol);
1282 seg_left = S_GET_SEGMENT (add_symbol);
1283 seg_right = S_GET_SEGMENT (op_symbol);
1285 /* Simplify addition or subtraction of a constant by folding the
1286 constant into X_add_number. */
1287 if (op == O_add)
1289 if (seg_right == absolute_section)
1291 final_val += right;
1292 goto do_symbol;
1294 else if (seg_left == absolute_section)
1296 final_val += left;
1297 add_symbol = op_symbol;
1298 left = right;
1299 seg_left = seg_right;
1300 goto do_symbol;
1303 else if (op == O_subtract)
1305 if (seg_right == absolute_section)
1307 final_val -= right;
1308 goto do_symbol;
1312 move_seg_ok = 1;
1313 /* Equality and non-equality tests are permitted on anything.
1314 Subtraction, and other comparison operators are permitted if
1315 both operands are in the same section. Otherwise, both
1316 operands must be absolute. We already handled the case of
1317 addition or subtraction of a constant above. This will
1318 probably need to be changed for an object file format which
1319 supports arbitrary expressions, such as IEEE-695. */
1320 if (!(seg_left == absolute_section
1321 && seg_right == absolute_section)
1322 && !(op == O_eq || op == O_ne)
1323 && !((op == O_subtract
1324 || op == O_lt || op == O_le || op == O_ge || op == O_gt)
1325 && seg_left == seg_right
1326 && (seg_left != undefined_section
1327 || add_symbol == op_symbol)))
1329 /* Don't emit messages unless we're finalizing the symbol value,
1330 otherwise we may get the same message multiple times. */
1331 if (finalize_syms)
1332 report_op_error (symp, add_symbol, op_symbol);
1333 /* However do not move the symbol into the absolute section
1334 if it cannot currently be resolved - this would confuse
1335 other parts of the assembler into believing that the
1336 expression had been evaluated to zero. */
1337 else
1338 move_seg_ok = 0;
1341 if (move_seg_ok
1342 && (final_seg == expr_section || final_seg == undefined_section))
1343 final_seg = absolute_section;
1345 /* Check for division by zero. */
1346 if ((op == O_divide || op == O_modulus) && right == 0)
1348 /* If seg_right is not absolute_section, then we've
1349 already issued a warning about using a bad symbol. */
1350 if (seg_right == absolute_section && finalize_syms)
1352 char *file;
1353 unsigned int line;
1355 if (expr_symbol_where (symp, &file, &line))
1356 as_bad_where (file, line, _("division by zero"));
1357 else
1358 as_bad (_("division by zero when setting `%s'"),
1359 S_GET_NAME (symp));
1362 right = 1;
1365 switch (symp->sy_value.X_op)
1367 case O_multiply: left *= right; break;
1368 case O_divide: left /= right; break;
1369 case O_modulus: left %= right; break;
1370 case O_left_shift: left <<= right; break;
1371 case O_right_shift: left >>= right; break;
1372 case O_bit_inclusive_or: left |= right; break;
1373 case O_bit_or_not: left |= ~right; break;
1374 case O_bit_exclusive_or: left ^= right; break;
1375 case O_bit_and: left &= right; break;
1376 case O_add: left += right; break;
1377 case O_subtract: left -= right; break;
1378 case O_eq:
1379 case O_ne:
1380 left = (left == right && seg_left == seg_right
1381 && (seg_left != undefined_section
1382 || add_symbol == op_symbol)
1383 ? ~ (offsetT) 0 : 0);
1384 if (symp->sy_value.X_op == O_ne)
1385 left = ~left;
1386 break;
1387 case O_lt: left = left < right ? ~ (offsetT) 0 : 0; break;
1388 case O_le: left = left <= right ? ~ (offsetT) 0 : 0; break;
1389 case O_ge: left = left >= right ? ~ (offsetT) 0 : 0; break;
1390 case O_gt: left = left > right ? ~ (offsetT) 0 : 0; break;
1391 case O_logical_and: left = left && right; break;
1392 case O_logical_or: left = left || right; break;
1393 default: abort ();
1396 final_val += symp->sy_frag->fr_address + left;
1397 if (final_seg == expr_section || final_seg == undefined_section)
1399 if (seg_left == undefined_section
1400 || seg_right == undefined_section)
1401 final_seg = undefined_section;
1402 else if (seg_left == absolute_section)
1403 final_seg = seg_right;
1404 else
1405 final_seg = seg_left;
1407 resolved = (symbol_resolved_p (add_symbol)
1408 && symbol_resolved_p (op_symbol));
1409 break;
1411 case O_big:
1412 case O_illegal:
1413 /* Give an error (below) if not in expr_section. We don't
1414 want to worry about expr_section symbols, because they
1415 are fictional (they are created as part of expression
1416 resolution), and any problems may not actually mean
1417 anything. */
1418 break;
1421 symp->sy_resolving = 0;
1424 if (finalize_syms)
1425 S_SET_VALUE (symp, final_val);
1427 exit_dont_set_value:
1428 /* Always set the segment, even if not finalizing the value.
1429 The segment is used to determine whether a symbol is defined. */
1430 S_SET_SEGMENT (symp, final_seg);
1432 /* Don't worry if we can't resolve an expr_section symbol. */
1433 if (finalize_syms)
1435 if (resolved)
1436 symp->sy_resolved = 1;
1437 else if (S_GET_SEGMENT (symp) != expr_section)
1439 as_bad (_("can't resolve value for symbol `%s'"),
1440 S_GET_NAME (symp));
1441 symp->sy_resolved = 1;
1445 return final_val;
1448 static void resolve_local_symbol (const char *, void *);
1450 /* A static function passed to hash_traverse. */
1452 static void
1453 resolve_local_symbol (const char *key ATTRIBUTE_UNUSED, void *value)
1455 if (value != NULL)
1456 resolve_symbol_value (value);
1459 /* Resolve all local symbols. */
1461 void
1462 resolve_local_symbol_values (void)
1464 hash_traverse (local_hash, resolve_local_symbol);
1467 /* Obtain the current value of a symbol without changing any
1468 sub-expressions used. */
1471 snapshot_symbol (symbolS **symbolPP, valueT *valueP, segT *segP, fragS **fragPP)
1473 symbolS *symbolP = *symbolPP;
1475 if (LOCAL_SYMBOL_CHECK (symbolP))
1477 struct local_symbol *locsym = (struct local_symbol *) symbolP;
1479 *valueP = locsym->lsy_value;
1480 *segP = locsym->lsy_section;
1481 *fragPP = local_symbol_get_frag (locsym);
1483 else
1485 expressionS expr = symbolP->sy_value;
1487 if (!symbolP->sy_resolved && expr.X_op != O_illegal)
1489 int resolved;
1491 if (symbolP->sy_resolving)
1492 return 0;
1493 symbolP->sy_resolving = 1;
1494 resolved = resolve_expression (&expr);
1495 symbolP->sy_resolving = 0;
1496 if (!resolved)
1497 return 0;
1499 switch (expr.X_op)
1501 case O_constant:
1502 case O_register:
1503 if (!symbol_equated_p (symbolP))
1504 break;
1505 /* Fall thru. */
1506 case O_symbol:
1507 case O_symbol_rva:
1508 symbolP = expr.X_add_symbol;
1509 break;
1510 default:
1511 return 0;
1515 /* Never change a defined symbol. */
1516 if (symbolP->bsym->section == undefined_section
1517 || symbolP->bsym->section == expr_section)
1518 *symbolPP = symbolP;
1519 *valueP = expr.X_add_number;
1520 *segP = symbolP->bsym->section;
1521 *fragPP = symbolP->sy_frag;
1523 if (*segP == expr_section)
1524 switch (expr.X_op)
1526 case O_constant: *segP = absolute_section; break;
1527 case O_register: *segP = reg_section; break;
1528 default: break;
1532 return 1;
1535 /* Dollar labels look like a number followed by a dollar sign. Eg, "42$".
1536 They are *really* local. That is, they go out of scope whenever we see a
1537 label that isn't local. Also, like fb labels, there can be multiple
1538 instances of a dollar label. Therefor, we name encode each instance with
1539 the instance number, keep a list of defined symbols separate from the real
1540 symbol table, and we treat these buggers as a sparse array. */
1542 static long *dollar_labels;
1543 static long *dollar_label_instances;
1544 static char *dollar_label_defines;
1545 static unsigned long dollar_label_count;
1546 static unsigned long dollar_label_max;
1549 dollar_label_defined (long label)
1551 long *i;
1553 know ((dollar_labels != NULL) || (dollar_label_count == 0));
1555 for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
1556 if (*i == label)
1557 return dollar_label_defines[i - dollar_labels];
1559 /* If we get here, label isn't defined. */
1560 return 0;
1563 static long
1564 dollar_label_instance (long label)
1566 long *i;
1568 know ((dollar_labels != NULL) || (dollar_label_count == 0));
1570 for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
1571 if (*i == label)
1572 return (dollar_label_instances[i - dollar_labels]);
1574 /* If we get here, we haven't seen the label before.
1575 Therefore its instance count is zero. */
1576 return 0;
1579 void
1580 dollar_label_clear (void)
1582 memset (dollar_label_defines, '\0', (unsigned int) dollar_label_count);
1585 #define DOLLAR_LABEL_BUMP_BY 10
1587 void
1588 define_dollar_label (long label)
1590 long *i;
1592 for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
1593 if (*i == label)
1595 ++dollar_label_instances[i - dollar_labels];
1596 dollar_label_defines[i - dollar_labels] = 1;
1597 return;
1600 /* If we get to here, we don't have label listed yet. */
1602 if (dollar_labels == NULL)
1604 dollar_labels = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long));
1605 dollar_label_instances = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long));
1606 dollar_label_defines = xmalloc (DOLLAR_LABEL_BUMP_BY);
1607 dollar_label_max = DOLLAR_LABEL_BUMP_BY;
1608 dollar_label_count = 0;
1610 else if (dollar_label_count == dollar_label_max)
1612 dollar_label_max += DOLLAR_LABEL_BUMP_BY;
1613 dollar_labels = (long *) xrealloc ((char *) dollar_labels,
1614 dollar_label_max * sizeof (long));
1615 dollar_label_instances = (long *) xrealloc ((char *) dollar_label_instances,
1616 dollar_label_max * sizeof (long));
1617 dollar_label_defines = xrealloc (dollar_label_defines, dollar_label_max);
1618 } /* if we needed to grow */
1620 dollar_labels[dollar_label_count] = label;
1621 dollar_label_instances[dollar_label_count] = 1;
1622 dollar_label_defines[dollar_label_count] = 1;
1623 ++dollar_label_count;
1626 /* Caller must copy returned name: we re-use the area for the next name.
1628 The mth occurence of label n: is turned into the symbol "Ln^Am"
1629 where n is the label number and m is the instance number. "L" makes
1630 it a label discarded unless debugging and "^A"('\1') ensures no
1631 ordinary symbol SHOULD get the same name as a local label
1632 symbol. The first "4:" is "L4^A1" - the m numbers begin at 1.
1634 fb labels get the same treatment, except that ^B is used in place
1635 of ^A. */
1637 char * /* Return local label name. */
1638 dollar_label_name (register long n, /* we just saw "n$:" : n a number. */
1639 register int augend /* 0 for current instance, 1 for new instance. */)
1641 long i;
1642 /* Returned to caller, then copied. Used for created names ("4f"). */
1643 static char symbol_name_build[24];
1644 register char *p;
1645 register char *q;
1646 char symbol_name_temporary[20]; /* Build up a number, BACKWARDS. */
1648 know (n >= 0);
1649 know (augend == 0 || augend == 1);
1650 p = symbol_name_build;
1651 #ifdef LOCAL_LABEL_PREFIX
1652 *p++ = LOCAL_LABEL_PREFIX;
1653 #endif
1654 *p++ = 'L';
1656 /* Next code just does sprintf( {}, "%d", n); */
1657 /* Label number. */
1658 q = symbol_name_temporary;
1659 for (*q++ = 0, i = n; i; ++q)
1661 *q = i % 10 + '0';
1662 i /= 10;
1664 while ((*p = *--q) != '\0')
1665 ++p;
1667 *p++ = DOLLAR_LABEL_CHAR; /* ^A */
1669 /* Instance number. */
1670 q = symbol_name_temporary;
1671 for (*q++ = 0, i = dollar_label_instance (n) + augend; i; ++q)
1673 *q = i % 10 + '0';
1674 i /= 10;
1676 while ((*p++ = *--q) != '\0');;
1678 /* The label, as a '\0' ended string, starts at symbol_name_build. */
1679 return symbol_name_build;
1682 /* Somebody else's idea of local labels. They are made by "n:" where n
1683 is any decimal digit. Refer to them with
1684 "nb" for previous (backward) n:
1685 or "nf" for next (forward) n:.
1687 We do a little better and let n be any number, not just a single digit, but
1688 since the other guy's assembler only does ten, we treat the first ten
1689 specially.
1691 Like someone else's assembler, we have one set of local label counters for
1692 entire assembly, not one set per (sub)segment like in most assemblers. This
1693 implies that one can refer to a label in another segment, and indeed some
1694 crufty compilers have done just that.
1696 Since there could be a LOT of these things, treat them as a sparse
1697 array. */
1699 #define FB_LABEL_SPECIAL (10)
1701 static long fb_low_counter[FB_LABEL_SPECIAL];
1702 static long *fb_labels;
1703 static long *fb_label_instances;
1704 static long fb_label_count;
1705 static long fb_label_max;
1707 /* This must be more than FB_LABEL_SPECIAL. */
1708 #define FB_LABEL_BUMP_BY (FB_LABEL_SPECIAL + 6)
1710 static void
1711 fb_label_init (void)
1713 memset ((void *) fb_low_counter, '\0', sizeof (fb_low_counter));
1716 /* Add one to the instance number of this fb label. */
1718 void
1719 fb_label_instance_inc (long label)
1721 long *i;
1723 if (label < FB_LABEL_SPECIAL)
1725 ++fb_low_counter[label];
1726 return;
1729 if (fb_labels != NULL)
1731 for (i = fb_labels + FB_LABEL_SPECIAL;
1732 i < fb_labels + fb_label_count; ++i)
1734 if (*i == label)
1736 ++fb_label_instances[i - fb_labels];
1737 return;
1738 } /* if we find it */
1739 } /* for each existing label */
1742 /* If we get to here, we don't have label listed yet. */
1744 if (fb_labels == NULL)
1746 fb_labels = (long *) xmalloc (FB_LABEL_BUMP_BY * sizeof (long));
1747 fb_label_instances = (long *) xmalloc (FB_LABEL_BUMP_BY * sizeof (long));
1748 fb_label_max = FB_LABEL_BUMP_BY;
1749 fb_label_count = FB_LABEL_SPECIAL;
1752 else if (fb_label_count == fb_label_max)
1754 fb_label_max += FB_LABEL_BUMP_BY;
1755 fb_labels = (long *) xrealloc ((char *) fb_labels,
1756 fb_label_max * sizeof (long));
1757 fb_label_instances = (long *) xrealloc ((char *) fb_label_instances,
1758 fb_label_max * sizeof (long));
1759 } /* if we needed to grow */
1761 fb_labels[fb_label_count] = label;
1762 fb_label_instances[fb_label_count] = 1;
1763 ++fb_label_count;
1766 static long
1767 fb_label_instance (long label)
1769 long *i;
1771 if (label < FB_LABEL_SPECIAL)
1773 return (fb_low_counter[label]);
1776 if (fb_labels != NULL)
1778 for (i = fb_labels + FB_LABEL_SPECIAL;
1779 i < fb_labels + fb_label_count; ++i)
1781 if (*i == label)
1783 return (fb_label_instances[i - fb_labels]);
1784 } /* if we find it */
1785 } /* for each existing label */
1788 /* We didn't find the label, so this must be a reference to the
1789 first instance. */
1790 return 0;
1793 /* Caller must copy returned name: we re-use the area for the next name.
1795 The mth occurence of label n: is turned into the symbol "Ln^Bm"
1796 where n is the label number and m is the instance number. "L" makes
1797 it a label discarded unless debugging and "^B"('\2') ensures no
1798 ordinary symbol SHOULD get the same name as a local label
1799 symbol. The first "4:" is "L4^B1" - the m numbers begin at 1.
1801 dollar labels get the same treatment, except that ^A is used in
1802 place of ^B. */
1804 char * /* Return local label name. */
1805 fb_label_name (long n, /* We just saw "n:", "nf" or "nb" : n a number. */
1806 long augend /* 0 for nb, 1 for n:, nf. */)
1808 long i;
1809 /* Returned to caller, then copied. Used for created names ("4f"). */
1810 static char symbol_name_build[24];
1811 register char *p;
1812 register char *q;
1813 char symbol_name_temporary[20]; /* Build up a number, BACKWARDS. */
1815 know (n >= 0);
1816 #ifdef TC_MMIX
1817 know ((unsigned long) augend <= 2 /* See mmix_fb_label. */);
1818 #else
1819 know ((unsigned long) augend <= 1);
1820 #endif
1821 p = symbol_name_build;
1822 #ifdef LOCAL_LABEL_PREFIX
1823 *p++ = LOCAL_LABEL_PREFIX;
1824 #endif
1825 *p++ = 'L';
1827 /* Next code just does sprintf( {}, "%d", n); */
1828 /* Label number. */
1829 q = symbol_name_temporary;
1830 for (*q++ = 0, i = n; i; ++q)
1832 *q = i % 10 + '0';
1833 i /= 10;
1835 while ((*p = *--q) != '\0')
1836 ++p;
1838 *p++ = LOCAL_LABEL_CHAR; /* ^B */
1840 /* Instance number. */
1841 q = symbol_name_temporary;
1842 for (*q++ = 0, i = fb_label_instance (n) + augend; i; ++q)
1844 *q = i % 10 + '0';
1845 i /= 10;
1847 while ((*p++ = *--q) != '\0');;
1849 /* The label, as a '\0' ended string, starts at symbol_name_build. */
1850 return (symbol_name_build);
1853 /* Decode name that may have been generated by foo_label_name() above.
1854 If the name wasn't generated by foo_label_name(), then return it
1855 unaltered. This is used for error messages. */
1857 char *
1858 decode_local_label_name (char *s)
1860 char *p;
1861 char *symbol_decode;
1862 int label_number;
1863 int instance_number;
1864 char *type;
1865 const char *message_format;
1866 int index = 0;
1868 #ifdef LOCAL_LABEL_PREFIX
1869 if (s[index] == LOCAL_LABEL_PREFIX)
1870 ++index;
1871 #endif
1873 if (s[index] != 'L')
1874 return s;
1876 for (label_number = 0, p = s + index + 1; ISDIGIT (*p); ++p)
1877 label_number = (10 * label_number) + *p - '0';
1879 if (*p == DOLLAR_LABEL_CHAR)
1880 type = "dollar";
1881 else if (*p == LOCAL_LABEL_CHAR)
1882 type = "fb";
1883 else
1884 return s;
1886 for (instance_number = 0, p++; ISDIGIT (*p); ++p)
1887 instance_number = (10 * instance_number) + *p - '0';
1889 message_format = _("\"%d\" (instance number %d of a %s label)");
1890 symbol_decode = obstack_alloc (&notes, strlen (message_format) + 30);
1891 sprintf (symbol_decode, message_format, label_number, instance_number, type);
1893 return symbol_decode;
1896 /* Get the value of a symbol. */
1898 valueT
1899 S_GET_VALUE (symbolS *s)
1901 if (LOCAL_SYMBOL_CHECK (s))
1902 return resolve_symbol_value (s);
1904 if (!s->sy_resolved)
1906 valueT val = resolve_symbol_value (s);
1907 if (!finalize_syms)
1908 return val;
1910 if (S_IS_WEAKREFR (s))
1911 return S_GET_VALUE (s->sy_value.X_add_symbol);
1913 if (s->sy_value.X_op != O_constant)
1915 if (! s->sy_resolved
1916 || s->sy_value.X_op != O_symbol
1917 || (S_IS_DEFINED (s) && ! S_IS_COMMON (s)))
1918 as_bad (_("attempt to get value of unresolved symbol `%s'"),
1919 S_GET_NAME (s));
1921 return (valueT) s->sy_value.X_add_number;
1924 /* Set the value of a symbol. */
1926 void
1927 S_SET_VALUE (symbolS *s, valueT val)
1929 if (LOCAL_SYMBOL_CHECK (s))
1931 ((struct local_symbol *) s)->lsy_value = val;
1932 return;
1935 s->sy_value.X_op = O_constant;
1936 s->sy_value.X_add_number = (offsetT) val;
1937 s->sy_value.X_unsigned = 0;
1938 S_CLEAR_WEAKREFR (s);
1941 void
1942 copy_symbol_attributes (symbolS *dest, symbolS *src)
1944 if (LOCAL_SYMBOL_CHECK (dest))
1945 dest = local_symbol_convert ((struct local_symbol *) dest);
1946 if (LOCAL_SYMBOL_CHECK (src))
1947 src = local_symbol_convert ((struct local_symbol *) src);
1949 /* In an expression, transfer the settings of these flags.
1950 The user can override later, of course. */
1951 #define COPIED_SYMFLAGS (BSF_FUNCTION | BSF_OBJECT)
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 || (EXTERN_FORCE_RELOC
2056 && (s->bsym->flags & BSF_GLOBAL) != 0)))
2057 || s->bsym->section == undefined_section
2058 || bfd_is_com_section (s->bsym->section));
2062 S_IS_DEBUG (symbolS *s)
2064 if (LOCAL_SYMBOL_CHECK (s))
2065 return 0;
2066 if (s->bsym->flags & BSF_DEBUGGING)
2067 return 1;
2068 return 0;
2072 S_IS_LOCAL (symbolS *s)
2074 flagword flags;
2075 const char *name;
2077 if (LOCAL_SYMBOL_CHECK (s))
2078 return 1;
2080 flags = s->bsym->flags;
2082 /* Sanity check. */
2083 if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL))
2084 abort ();
2086 if (bfd_get_section (s->bsym) == reg_section)
2087 return 1;
2089 if (flag_strip_local_absolute
2090 /* Keep BSF_FILE symbols in order to allow debuggers to identify
2091 the source file even when the object file is stripped. */
2092 && (flags & (BSF_GLOBAL | BSF_FILE)) == 0
2093 && bfd_get_section (s->bsym) == absolute_section)
2094 return 1;
2096 name = S_GET_NAME (s);
2097 return (name != NULL
2098 && ! S_IS_DEBUG (s)
2099 && (strchr (name, DOLLAR_LABEL_CHAR)
2100 || strchr (name, LOCAL_LABEL_CHAR)
2101 || (! flag_keep_locals
2102 && (bfd_is_local_label (stdoutput, s->bsym)
2103 || (flag_mri
2104 && name[0] == '?'
2105 && name[1] == '?')))));
2109 S_IS_STABD (symbolS *s)
2111 return S_GET_NAME (s) == 0;
2115 S_IS_VOLATILE (const symbolS *s)
2117 if (LOCAL_SYMBOL_CHECK (s))
2118 return 0;
2119 return s->sy_volatile;
2123 S_IS_FORWARD_REF (const symbolS *s)
2125 if (LOCAL_SYMBOL_CHECK (s))
2126 return 0;
2127 return s->sy_forward_ref;
2130 const char *
2131 S_GET_NAME (symbolS *s)
2133 if (LOCAL_SYMBOL_CHECK (s))
2134 return ((struct local_symbol *) s)->lsy_name;
2135 return s->bsym->name;
2138 segT
2139 S_GET_SEGMENT (symbolS *s)
2141 if (LOCAL_SYMBOL_CHECK (s))
2142 return ((struct local_symbol *) s)->lsy_section;
2143 return s->bsym->section;
2146 void
2147 S_SET_SEGMENT (symbolS *s, segT seg)
2149 /* Don't reassign section symbols. The direct reason is to prevent seg
2150 faults assigning back to const global symbols such as *ABS*, but it
2151 shouldn't happen anyway. */
2153 if (LOCAL_SYMBOL_CHECK (s))
2155 if (seg == reg_section)
2156 s = local_symbol_convert ((struct local_symbol *) s);
2157 else
2159 ((struct local_symbol *) s)->lsy_section = seg;
2160 return;
2164 if (s->bsym->flags & BSF_SECTION_SYM)
2166 if (s->bsym->section != seg)
2167 abort ();
2169 else
2170 s->bsym->section = seg;
2173 void
2174 S_SET_EXTERNAL (symbolS *s)
2176 if (LOCAL_SYMBOL_CHECK (s))
2177 s = local_symbol_convert ((struct local_symbol *) s);
2178 if ((s->bsym->flags & BSF_WEAK) != 0)
2180 /* Let .weak override .global. */
2181 return;
2183 if (s->bsym->flags & BSF_SECTION_SYM)
2185 char * file;
2186 unsigned int line;
2188 /* Do not reassign section symbols. */
2189 as_where (& file, & line);
2190 as_warn_where (file, line,
2191 _("section symbols are already global"));
2192 return;
2194 #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
2195 if (S_GET_SEGMENT (s) == reg_section)
2197 as_bad ("can't make register symbol `%s' global",
2198 S_GET_NAME (s));
2199 return;
2201 #endif
2202 s->bsym->flags |= BSF_GLOBAL;
2203 s->bsym->flags &= ~(BSF_LOCAL | BSF_WEAK);
2205 #ifdef USE_UNIQUE
2206 if (! an_external_name && S_GET_NAME(s)[0] != '.')
2207 an_external_name = S_GET_NAME (s);
2208 #endif
2211 void
2212 S_CLEAR_EXTERNAL (symbolS *s)
2214 if (LOCAL_SYMBOL_CHECK (s))
2215 return;
2216 if ((s->bsym->flags & BSF_WEAK) != 0)
2218 /* Let .weak override. */
2219 return;
2221 s->bsym->flags |= BSF_LOCAL;
2222 s->bsym->flags &= ~(BSF_GLOBAL | BSF_WEAK);
2225 void
2226 S_SET_WEAK (symbolS *s)
2228 if (LOCAL_SYMBOL_CHECK (s))
2229 s = local_symbol_convert ((struct local_symbol *) s);
2230 #ifdef obj_set_weak_hook
2231 obj_set_weak_hook (s);
2232 #endif
2233 s->bsym->flags |= BSF_WEAK;
2234 s->bsym->flags &= ~(BSF_GLOBAL | BSF_LOCAL);
2237 void
2238 S_SET_WEAKREFR (symbolS *s)
2240 if (LOCAL_SYMBOL_CHECK (s))
2241 s = local_symbol_convert ((struct local_symbol *) s);
2242 s->sy_weakrefr = 1;
2243 /* If the alias was already used, make sure we mark the target as
2244 used as well, otherwise it might be dropped from the symbol
2245 table. This may have unintended side effects if the alias is
2246 later redirected to another symbol, such as keeping the unused
2247 previous target in the symbol table. Since it will be weak, it's
2248 not a big deal. */
2249 if (s->sy_used)
2250 symbol_mark_used (s->sy_value.X_add_symbol);
2253 void
2254 S_CLEAR_WEAKREFR (symbolS *s)
2256 if (LOCAL_SYMBOL_CHECK (s))
2257 return;
2258 s->sy_weakrefr = 0;
2261 void
2262 S_SET_WEAKREFD (symbolS *s)
2264 if (LOCAL_SYMBOL_CHECK (s))
2265 s = local_symbol_convert ((struct local_symbol *) s);
2266 s->sy_weakrefd = 1;
2267 S_SET_WEAK (s);
2270 void
2271 S_CLEAR_WEAKREFD (symbolS *s)
2273 if (LOCAL_SYMBOL_CHECK (s))
2274 return;
2275 if (s->sy_weakrefd)
2277 s->sy_weakrefd = 0;
2278 /* If a weakref target symbol is weak, then it was never
2279 referenced directly before, not even in a .global directive,
2280 so decay it to local. If it remains undefined, it will be
2281 later turned into a global, like any other undefined
2282 symbol. */
2283 if (s->bsym->flags & BSF_WEAK)
2285 #ifdef obj_clear_weak_hook
2286 obj_clear_weak_hook (s);
2287 #endif
2288 s->bsym->flags &= ~BSF_WEAK;
2289 s->bsym->flags |= BSF_LOCAL;
2294 void
2295 S_SET_THREAD_LOCAL (symbolS *s)
2297 if (LOCAL_SYMBOL_CHECK (s))
2298 s = local_symbol_convert ((struct local_symbol *) s);
2299 if (bfd_is_com_section (s->bsym->section)
2300 && (s->bsym->flags & BSF_THREAD_LOCAL) != 0)
2301 return;
2302 s->bsym->flags |= BSF_THREAD_LOCAL;
2303 if ((s->bsym->flags & BSF_FUNCTION) != 0)
2304 as_bad (_("Accessing function `%s' as thread-local object"),
2305 S_GET_NAME (s));
2306 else if (! bfd_is_und_section (s->bsym->section)
2307 && (s->bsym->section->flags & SEC_THREAD_LOCAL) == 0)
2308 as_bad (_("Accessing `%s' as thread-local object"),
2309 S_GET_NAME (s));
2312 void
2313 S_SET_NAME (symbolS *s, const char *name)
2315 if (LOCAL_SYMBOL_CHECK (s))
2317 ((struct local_symbol *) s)->lsy_name = name;
2318 return;
2320 s->bsym->name = name;
2323 void
2324 S_SET_VOLATILE (symbolS *s)
2326 if (LOCAL_SYMBOL_CHECK (s))
2327 s = local_symbol_convert ((struct local_symbol *) s);
2328 s->sy_volatile = 1;
2331 void
2332 S_CLEAR_VOLATILE (symbolS *s)
2334 if (!LOCAL_SYMBOL_CHECK (s))
2335 s->sy_volatile = 0;
2338 void
2339 S_SET_FORWARD_REF (symbolS *s)
2341 if (LOCAL_SYMBOL_CHECK (s))
2342 s = local_symbol_convert ((struct local_symbol *) s);
2343 s->sy_forward_ref = 1;
2346 /* Return the previous symbol in a chain. */
2348 symbolS *
2349 symbol_previous (symbolS *s)
2351 if (LOCAL_SYMBOL_CHECK (s))
2352 abort ();
2353 return s->sy_previous;
2356 /* Return the next symbol in a chain. */
2358 symbolS *
2359 symbol_next (symbolS *s)
2361 if (LOCAL_SYMBOL_CHECK (s))
2362 abort ();
2363 return s->sy_next;
2366 /* Return a pointer to the value of a symbol as an expression. */
2368 expressionS *
2369 symbol_get_value_expression (symbolS *s)
2371 if (LOCAL_SYMBOL_CHECK (s))
2372 s = local_symbol_convert ((struct local_symbol *) s);
2373 return &s->sy_value;
2376 /* Set the value of a symbol to an expression. */
2378 void
2379 symbol_set_value_expression (symbolS *s, const expressionS *exp)
2381 if (LOCAL_SYMBOL_CHECK (s))
2382 s = local_symbol_convert ((struct local_symbol *) s);
2383 s->sy_value = *exp;
2384 S_CLEAR_WEAKREFR (s);
2387 /* Return a pointer to the X_add_number component of a symbol. */
2389 offsetT *
2390 symbol_X_add_number (symbolS *s)
2392 if (LOCAL_SYMBOL_CHECK (s))
2393 return (offsetT *) &((struct local_symbol *) s)->lsy_value;
2395 return &s->sy_value.X_add_number;
2398 /* Set the value of SYM to the current position in the current segment. */
2400 void
2401 symbol_set_value_now (symbolS *sym)
2403 S_SET_SEGMENT (sym, now_seg);
2404 S_SET_VALUE (sym, frag_now_fix ());
2405 symbol_set_frag (sym, frag_now);
2408 /* Set the frag of a symbol. */
2410 void
2411 symbol_set_frag (symbolS *s, fragS *f)
2413 if (LOCAL_SYMBOL_CHECK (s))
2415 local_symbol_set_frag ((struct local_symbol *) s, f);
2416 return;
2418 s->sy_frag = f;
2419 S_CLEAR_WEAKREFR (s);
2422 /* Return the frag of a symbol. */
2424 fragS *
2425 symbol_get_frag (symbolS *s)
2427 if (LOCAL_SYMBOL_CHECK (s))
2428 return local_symbol_get_frag ((struct local_symbol *) s);
2429 return s->sy_frag;
2432 /* Mark a symbol as having been used. */
2434 void
2435 symbol_mark_used (symbolS *s)
2437 if (LOCAL_SYMBOL_CHECK (s))
2438 return;
2439 s->sy_used = 1;
2440 if (S_IS_WEAKREFR (s))
2441 symbol_mark_used (s->sy_value.X_add_symbol);
2444 /* Clear the mark of whether a symbol has been used. */
2446 void
2447 symbol_clear_used (symbolS *s)
2449 if (LOCAL_SYMBOL_CHECK (s))
2450 s = local_symbol_convert ((struct local_symbol *) s);
2451 s->sy_used = 0;
2454 /* Return whether a symbol has been used. */
2457 symbol_used_p (symbolS *s)
2459 if (LOCAL_SYMBOL_CHECK (s))
2460 return 1;
2461 return s->sy_used;
2464 /* Mark a symbol as having been used in a reloc. */
2466 void
2467 symbol_mark_used_in_reloc (symbolS *s)
2469 if (LOCAL_SYMBOL_CHECK (s))
2470 s = local_symbol_convert ((struct local_symbol *) s);
2471 s->sy_used_in_reloc = 1;
2474 /* Clear the mark of whether a symbol has been used in a reloc. */
2476 void
2477 symbol_clear_used_in_reloc (symbolS *s)
2479 if (LOCAL_SYMBOL_CHECK (s))
2480 return;
2481 s->sy_used_in_reloc = 0;
2484 /* Return whether a symbol has been used in a reloc. */
2487 symbol_used_in_reloc_p (symbolS *s)
2489 if (LOCAL_SYMBOL_CHECK (s))
2490 return 0;
2491 return s->sy_used_in_reloc;
2494 /* Mark a symbol as an MRI common symbol. */
2496 void
2497 symbol_mark_mri_common (symbolS *s)
2499 if (LOCAL_SYMBOL_CHECK (s))
2500 s = local_symbol_convert ((struct local_symbol *) s);
2501 s->sy_mri_common = 1;
2504 /* Clear the mark of whether a symbol is an MRI common symbol. */
2506 void
2507 symbol_clear_mri_common (symbolS *s)
2509 if (LOCAL_SYMBOL_CHECK (s))
2510 return;
2511 s->sy_mri_common = 0;
2514 /* Return whether a symbol is an MRI common symbol. */
2517 symbol_mri_common_p (symbolS *s)
2519 if (LOCAL_SYMBOL_CHECK (s))
2520 return 0;
2521 return s->sy_mri_common;
2524 /* Mark a symbol as having been written. */
2526 void
2527 symbol_mark_written (symbolS *s)
2529 if (LOCAL_SYMBOL_CHECK (s))
2530 return;
2531 s->written = 1;
2534 /* Clear the mark of whether a symbol has been written. */
2536 void
2537 symbol_clear_written (symbolS *s)
2539 if (LOCAL_SYMBOL_CHECK (s))
2540 return;
2541 s->written = 0;
2544 /* Return whether a symbol has been written. */
2547 symbol_written_p (symbolS *s)
2549 if (LOCAL_SYMBOL_CHECK (s))
2550 return 0;
2551 return s->written;
2554 /* Mark a symbol has having been resolved. */
2556 void
2557 symbol_mark_resolved (symbolS *s)
2559 if (LOCAL_SYMBOL_CHECK (s))
2561 local_symbol_mark_resolved ((struct local_symbol *) s);
2562 return;
2564 s->sy_resolved = 1;
2567 /* Return whether a symbol has been resolved. */
2570 symbol_resolved_p (symbolS *s)
2572 if (LOCAL_SYMBOL_CHECK (s))
2573 return local_symbol_resolved_p ((struct local_symbol *) s);
2574 return s->sy_resolved;
2577 /* Return whether a symbol is a section symbol. */
2580 symbol_section_p (symbolS *s ATTRIBUTE_UNUSED)
2582 if (LOCAL_SYMBOL_CHECK (s))
2583 return 0;
2584 return (s->bsym->flags & BSF_SECTION_SYM) != 0;
2587 /* Return whether a symbol is equated to another symbol. */
2590 symbol_equated_p (symbolS *s)
2592 if (LOCAL_SYMBOL_CHECK (s))
2593 return 0;
2594 return s->sy_value.X_op == O_symbol;
2597 /* Return whether a symbol is equated to another symbol, and should be
2598 treated specially when writing out relocs. */
2601 symbol_equated_reloc_p (symbolS *s)
2603 if (LOCAL_SYMBOL_CHECK (s))
2604 return 0;
2605 /* X_op_symbol, normally not used for O_symbol, is set by
2606 resolve_symbol_value to flag expression syms that have been
2607 equated. */
2608 return (s->sy_value.X_op == O_symbol
2609 #if defined (OBJ_COFF) && defined (TE_PE)
2610 && ! S_IS_WEAK (s)
2611 #endif
2612 && ((s->sy_resolved && s->sy_value.X_op_symbol != NULL)
2613 || ! S_IS_DEFINED (s)
2614 || S_IS_COMMON (s)));
2617 /* Return whether a symbol has a constant value. */
2620 symbol_constant_p (symbolS *s)
2622 if (LOCAL_SYMBOL_CHECK (s))
2623 return 1;
2624 return s->sy_value.X_op == O_constant;
2627 /* Return whether a symbol was cloned and thus removed from the global
2628 symbol list. */
2631 symbol_shadow_p (symbolS *s)
2633 if (LOCAL_SYMBOL_CHECK (s))
2634 return 0;
2635 return s->sy_next == s;
2638 /* Return the BFD symbol for a symbol. */
2640 asymbol *
2641 symbol_get_bfdsym (symbolS *s)
2643 if (LOCAL_SYMBOL_CHECK (s))
2644 s = local_symbol_convert ((struct local_symbol *) s);
2645 return s->bsym;
2648 /* Set the BFD symbol for a symbol. */
2650 void
2651 symbol_set_bfdsym (symbolS *s, asymbol *bsym)
2653 if (LOCAL_SYMBOL_CHECK (s))
2654 s = local_symbol_convert ((struct local_symbol *) s);
2655 /* Usually, it is harmless to reset a symbol to a BFD section
2656 symbol. For example, obj_elf_change_section sets the BFD symbol
2657 of an old symbol with the newly created section symbol. But when
2658 we have multiple sections with the same name, the newly created
2659 section may have the same name as an old section. We check if the
2660 old symbol has been already marked as a section symbol before
2661 resetting it. */
2662 if ((s->bsym->flags & BSF_SECTION_SYM) == 0)
2663 s->bsym = bsym;
2664 /* else XXX - What do we do now ? */
2667 #ifdef OBJ_SYMFIELD_TYPE
2669 /* Get a pointer to the object format information for a symbol. */
2671 OBJ_SYMFIELD_TYPE *
2672 symbol_get_obj (symbolS *s)
2674 if (LOCAL_SYMBOL_CHECK (s))
2675 s = local_symbol_convert ((struct local_symbol *) s);
2676 return &s->sy_obj;
2679 /* Set the object format information for a symbol. */
2681 void
2682 symbol_set_obj (symbolS *s, OBJ_SYMFIELD_TYPE *o)
2684 if (LOCAL_SYMBOL_CHECK (s))
2685 s = local_symbol_convert ((struct local_symbol *) s);
2686 s->sy_obj = *o;
2689 #endif /* OBJ_SYMFIELD_TYPE */
2691 #ifdef TC_SYMFIELD_TYPE
2693 /* Get a pointer to the processor information for a symbol. */
2695 TC_SYMFIELD_TYPE *
2696 symbol_get_tc (symbolS *s)
2698 if (LOCAL_SYMBOL_CHECK (s))
2699 s = local_symbol_convert ((struct local_symbol *) s);
2700 return &s->sy_tc;
2703 /* Set the processor information for a symbol. */
2705 void
2706 symbol_set_tc (symbolS *s, TC_SYMFIELD_TYPE *o)
2708 if (LOCAL_SYMBOL_CHECK (s))
2709 s = local_symbol_convert ((struct local_symbol *) s);
2710 s->sy_tc = *o;
2713 #endif /* TC_SYMFIELD_TYPE */
2715 void
2716 symbol_begin (void)
2718 symbol_lastP = NULL;
2719 symbol_rootP = NULL; /* In case we have 0 symbols (!!) */
2720 sy_hash = hash_new ();
2721 local_hash = hash_new ();
2723 memset ((char *) (&abs_symbol), '\0', sizeof (abs_symbol));
2724 #if defined (EMIT_SECTION_SYMBOLS) || !defined (RELOC_REQUIRES_SYMBOL)
2725 abs_symbol.bsym = bfd_abs_section.symbol;
2726 #endif
2727 abs_symbol.sy_value.X_op = O_constant;
2728 abs_symbol.sy_frag = &zero_address_frag;
2730 if (LOCAL_LABELS_FB)
2731 fb_label_init ();
2734 int indent_level;
2736 /* Maximum indent level.
2737 Available for modification inside a gdb session. */
2738 static int max_indent_level = 8;
2740 void
2741 print_symbol_value_1 (FILE *file, symbolS *sym)
2743 const char *name = S_GET_NAME (sym);
2744 if (!name || !name[0])
2745 name = "(unnamed)";
2746 fprintf (file, "sym ");
2747 fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) sym));
2748 fprintf (file, " %s", name);
2750 if (LOCAL_SYMBOL_CHECK (sym))
2752 struct local_symbol *locsym = (struct local_symbol *) sym;
2754 if (local_symbol_get_frag (locsym) != & zero_address_frag
2755 && local_symbol_get_frag (locsym) != NULL)
2757 fprintf (file, " frag ");
2758 fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) local_symbol_get_frag (locsym)));
2760 if (local_symbol_resolved_p (locsym))
2761 fprintf (file, " resolved");
2762 fprintf (file, " local");
2764 else
2766 if (sym->sy_frag != &zero_address_frag)
2768 fprintf (file, " frag ");
2769 fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) sym->sy_frag));
2771 if (sym->written)
2772 fprintf (file, " written");
2773 if (sym->sy_resolved)
2774 fprintf (file, " resolved");
2775 else if (sym->sy_resolving)
2776 fprintf (file, " resolving");
2777 if (sym->sy_used_in_reloc)
2778 fprintf (file, " used-in-reloc");
2779 if (sym->sy_used)
2780 fprintf (file, " used");
2781 if (S_IS_LOCAL (sym))
2782 fprintf (file, " local");
2783 if (S_IS_EXTERNAL (sym))
2784 fprintf (file, " extern");
2785 if (S_IS_WEAK (sym))
2786 fprintf (file, " weak");
2787 if (S_IS_DEBUG (sym))
2788 fprintf (file, " debug");
2789 if (S_IS_DEFINED (sym))
2790 fprintf (file, " defined");
2792 if (S_IS_WEAKREFR (sym))
2793 fprintf (file, " weakrefr");
2794 if (S_IS_WEAKREFD (sym))
2795 fprintf (file, " weakrefd");
2796 fprintf (file, " %s", segment_name (S_GET_SEGMENT (sym)));
2797 if (symbol_resolved_p (sym))
2799 segT s = S_GET_SEGMENT (sym);
2801 if (s != undefined_section
2802 && s != expr_section)
2803 fprintf (file, " %lx", (unsigned long) S_GET_VALUE (sym));
2805 else if (indent_level < max_indent_level
2806 && S_GET_SEGMENT (sym) != undefined_section)
2808 indent_level++;
2809 fprintf (file, "\n%*s<", indent_level * 4, "");
2810 if (LOCAL_SYMBOL_CHECK (sym))
2811 fprintf (file, "constant %lx",
2812 (unsigned long) ((struct local_symbol *) sym)->lsy_value);
2813 else
2814 print_expr_1 (file, &sym->sy_value);
2815 fprintf (file, ">");
2816 indent_level--;
2818 fflush (file);
2821 void
2822 print_symbol_value (symbolS *sym)
2824 indent_level = 0;
2825 print_symbol_value_1 (stderr, sym);
2826 fprintf (stderr, "\n");
2829 static void
2830 print_binary (FILE *file, const char *name, expressionS *exp)
2832 indent_level++;
2833 fprintf (file, "%s\n%*s<", name, indent_level * 4, "");
2834 print_symbol_value_1 (file, exp->X_add_symbol);
2835 fprintf (file, ">\n%*s<", indent_level * 4, "");
2836 print_symbol_value_1 (file, exp->X_op_symbol);
2837 fprintf (file, ">");
2838 indent_level--;
2841 void
2842 print_expr_1 (FILE *file, expressionS *exp)
2844 fprintf (file, "expr ");
2845 fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) exp));
2846 fprintf (file, " ");
2847 switch (exp->X_op)
2849 case O_illegal:
2850 fprintf (file, "illegal");
2851 break;
2852 case O_absent:
2853 fprintf (file, "absent");
2854 break;
2855 case O_constant:
2856 fprintf (file, "constant %lx", (unsigned long) exp->X_add_number);
2857 break;
2858 case O_symbol:
2859 indent_level++;
2860 fprintf (file, "symbol\n%*s<", indent_level * 4, "");
2861 print_symbol_value_1 (file, exp->X_add_symbol);
2862 fprintf (file, ">");
2863 maybe_print_addnum:
2864 if (exp->X_add_number)
2865 fprintf (file, "\n%*s%lx", indent_level * 4, "",
2866 (unsigned long) exp->X_add_number);
2867 indent_level--;
2868 break;
2869 case O_register:
2870 fprintf (file, "register #%d", (int) exp->X_add_number);
2871 break;
2872 case O_big:
2873 fprintf (file, "big");
2874 break;
2875 case O_uminus:
2876 fprintf (file, "uminus -<");
2877 indent_level++;
2878 print_symbol_value_1 (file, exp->X_add_symbol);
2879 fprintf (file, ">");
2880 goto maybe_print_addnum;
2881 case O_bit_not:
2882 fprintf (file, "bit_not");
2883 break;
2884 case O_multiply:
2885 print_binary (file, "multiply", exp);
2886 break;
2887 case O_divide:
2888 print_binary (file, "divide", exp);
2889 break;
2890 case O_modulus:
2891 print_binary (file, "modulus", exp);
2892 break;
2893 case O_left_shift:
2894 print_binary (file, "lshift", exp);
2895 break;
2896 case O_right_shift:
2897 print_binary (file, "rshift", exp);
2898 break;
2899 case O_bit_inclusive_or:
2900 print_binary (file, "bit_ior", exp);
2901 break;
2902 case O_bit_exclusive_or:
2903 print_binary (file, "bit_xor", exp);
2904 break;
2905 case O_bit_and:
2906 print_binary (file, "bit_and", exp);
2907 break;
2908 case O_eq:
2909 print_binary (file, "eq", exp);
2910 break;
2911 case O_ne:
2912 print_binary (file, "ne", exp);
2913 break;
2914 case O_lt:
2915 print_binary (file, "lt", exp);
2916 break;
2917 case O_le:
2918 print_binary (file, "le", exp);
2919 break;
2920 case O_ge:
2921 print_binary (file, "ge", exp);
2922 break;
2923 case O_gt:
2924 print_binary (file, "gt", exp);
2925 break;
2926 case O_logical_and:
2927 print_binary (file, "logical_and", exp);
2928 break;
2929 case O_logical_or:
2930 print_binary (file, "logical_or", exp);
2931 break;
2932 case O_add:
2933 indent_level++;
2934 fprintf (file, "add\n%*s<", indent_level * 4, "");
2935 print_symbol_value_1 (file, exp->X_add_symbol);
2936 fprintf (file, ">\n%*s<", indent_level * 4, "");
2937 print_symbol_value_1 (file, exp->X_op_symbol);
2938 fprintf (file, ">");
2939 goto maybe_print_addnum;
2940 case O_subtract:
2941 indent_level++;
2942 fprintf (file, "subtract\n%*s<", indent_level * 4, "");
2943 print_symbol_value_1 (file, exp->X_add_symbol);
2944 fprintf (file, ">\n%*s<", indent_level * 4, "");
2945 print_symbol_value_1 (file, exp->X_op_symbol);
2946 fprintf (file, ">");
2947 goto maybe_print_addnum;
2948 default:
2949 fprintf (file, "{unknown opcode %d}", (int) exp->X_op);
2950 break;
2952 fflush (stdout);
2955 void
2956 print_expr (expressionS *exp)
2958 print_expr_1 (stderr, exp);
2959 fprintf (stderr, "\n");
2962 void
2963 symbol_print_statistics (FILE *file)
2965 hash_print_statistics (file, "symbol table", sy_hash);
2966 hash_print_statistics (file, "mini local symbol table", local_hash);
2967 fprintf (file, "%lu mini local symbols created, %lu converted\n",
2968 local_symbol_count, local_symbol_conversion_count);
2971 #ifdef OBJ_COMPLEX_RELC
2973 /* Convert given symbol to a new complex-relocation symbol name. This
2974 may be a recursive function, since it might be called for non-leaf
2975 nodes (plain symbols) in the expression tree. The caller owns the
2976 returning string, so should free it eventually. Errors are
2977 indicated via as_bad and a NULL return value. The given symbol
2978 is marked with sy_used_in_reloc. */
2980 char *
2981 symbol_relc_make_sym (symbolS * sym)
2983 char * terminal = NULL;
2984 const char * sname;
2985 char typetag;
2986 int sname_len;
2988 assert (sym != NULL);
2990 /* Recurse to symbol_relc_make_expr if this symbol
2991 is defined as an expression or a plain value. */
2992 if ( S_GET_SEGMENT (sym) == expr_section
2993 || S_GET_SEGMENT (sym) == absolute_section)
2994 return symbol_relc_make_expr (& sym->sy_value);
2996 /* This may be a "fake symbol" L0\001, referring to ".".
2997 Write out a special null symbol to refer to this position. */
2998 if (! strcmp (S_GET_NAME (sym), FAKE_LABEL_NAME))
2999 return xstrdup (".");
3001 /* We hope this is a plain leaf symbol. Construct the encoding
3002 as {S,s}II...:CCCCCCC....
3003 where 'S'/'s' means section symbol / plain symbol
3004 III is decimal for the symbol name length
3005 CCC is the symbol name itself. */
3006 symbol_mark_used_in_reloc (sym);
3008 sname = S_GET_NAME (sym);
3009 sname_len = strlen (sname);
3010 typetag = symbol_section_p (sym) ? 'S' : 's';
3012 terminal = xmalloc (1 /* S or s */
3013 + 8 /* sname_len in decimal */
3014 + 1 /* _ spacer */
3015 + sname_len /* name itself */
3016 + 1 /* \0 */ );
3018 sprintf (terminal, "%c%d:%s", typetag, sname_len, sname);
3019 return terminal;
3022 /* Convert given value to a new complex-relocation symbol name. This
3023 is a non-recursive function, since it is be called for leaf nodes
3024 (plain values) in the expression tree. The caller owns the
3025 returning string, so should free() it eventually. No errors. */
3027 char *
3028 symbol_relc_make_value (offsetT val)
3030 char * terminal = xmalloc (28); /* Enough for long long. */
3032 terminal[0] = '#';
3033 bfd_sprintf_vma (stdoutput, terminal + 1, val);
3034 return terminal;
3037 /* Convert given expression to a new complex-relocation symbol name.
3038 This is a recursive function, since it traverses the entire given
3039 expression tree. The caller owns the returning string, so should
3040 free() it eventually. Errors are indicated via as_bad() and a NULL
3041 return value. */
3043 char *
3044 symbol_relc_make_expr (expressionS * exp)
3046 char * opstr = NULL; /* Operator prefix string. */
3047 int arity = 0; /* Arity of this operator. */
3048 char * operands[3]; /* Up to three operands. */
3049 char * concat_string = NULL;
3051 operands[0] = operands[1] = operands[2] = NULL;
3053 assert (exp != NULL);
3055 /* Match known operators -> fill in opstr, arity, operands[] and fall
3056 through to construct subexpression fragments; may instead return
3057 string directly for leaf nodes. */
3059 /* See expr.h for the meaning of all these enums. Many operators
3060 have an unnatural arity (X_add_number implicitly added). The
3061 conversion logic expands them to explicit "+" subexpressions. */
3063 switch (exp->X_op)
3065 default:
3066 as_bad ("Unknown expression operator (enum %d)", exp->X_op);
3067 break;
3069 /* Leaf nodes. */
3070 case O_constant:
3071 return symbol_relc_make_value (exp->X_add_number);
3073 case O_symbol:
3074 if (exp->X_add_number)
3076 arity = 2;
3077 opstr = "+";
3078 operands[0] = symbol_relc_make_sym (exp->X_add_symbol);
3079 operands[1] = symbol_relc_make_value (exp->X_add_number);
3080 break;
3082 else
3083 return symbol_relc_make_sym (exp->X_add_symbol);
3085 /* Helper macros for nesting nodes. */
3087 #define HANDLE_XADD_OPT1(str_) \
3088 if (exp->X_add_number) \
3090 arity = 2; \
3091 opstr = "+:" str_; \
3092 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3093 operands[1] = symbol_relc_make_value (exp->X_add_number); \
3094 break; \
3096 else \
3098 arity = 1; \
3099 opstr = str_; \
3100 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3102 break
3104 #define HANDLE_XADD_OPT2(str_) \
3105 if (exp->X_add_number) \
3107 arity = 3; \
3108 opstr = "+:" str_; \
3109 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3110 operands[1] = symbol_relc_make_sym (exp->X_op_symbol); \
3111 operands[2] = symbol_relc_make_value (exp->X_add_number); \
3113 else \
3115 arity = 2; \
3116 opstr = str_; \
3117 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3118 operands[1] = symbol_relc_make_sym (exp->X_op_symbol); \
3120 break
3122 /* Nesting nodes. */
3124 case O_uminus: HANDLE_XADD_OPT1 ("0-");
3125 case O_bit_not: HANDLE_XADD_OPT1 ("~");
3126 case O_logical_not: HANDLE_XADD_OPT1 ("!");
3127 case O_multiply: HANDLE_XADD_OPT2 ("*");
3128 case O_divide: HANDLE_XADD_OPT2 ("/");
3129 case O_modulus: HANDLE_XADD_OPT2 ("%");
3130 case O_left_shift: HANDLE_XADD_OPT2 ("<<");
3131 case O_right_shift: HANDLE_XADD_OPT2 (">>");
3132 case O_bit_inclusive_or: HANDLE_XADD_OPT2 ("|");
3133 case O_bit_exclusive_or: HANDLE_XADD_OPT2 ("^");
3134 case O_bit_and: HANDLE_XADD_OPT2 ("&");
3135 case O_add: HANDLE_XADD_OPT2 ("+");
3136 case O_subtract: HANDLE_XADD_OPT2 ("-");
3137 case O_eq: HANDLE_XADD_OPT2 ("==");
3138 case O_ne: HANDLE_XADD_OPT2 ("!=");
3139 case O_lt: HANDLE_XADD_OPT2 ("<");
3140 case O_le: HANDLE_XADD_OPT2 ("<=");
3141 case O_ge: HANDLE_XADD_OPT2 (">=");
3142 case O_gt: HANDLE_XADD_OPT2 (">");
3143 case O_logical_and: HANDLE_XADD_OPT2 ("&&");
3144 case O_logical_or: HANDLE_XADD_OPT2 ("||");
3147 /* Validate & reject early. */
3148 if (arity >= 1 && ((operands[0] == NULL) || (strlen (operands[0]) == 0)))
3149 opstr = NULL;
3150 if (arity >= 2 && ((operands[1] == NULL) || (strlen (operands[1]) == 0)))
3151 opstr = NULL;
3152 if (arity >= 3 && ((operands[2] == NULL) || (strlen (operands[2]) == 0)))
3153 opstr = NULL;
3155 if (opstr == NULL)
3156 concat_string = NULL;
3157 else
3159 /* Allocate new string; include inter-operand padding gaps etc. */
3160 concat_string = xmalloc (strlen (opstr)
3162 + (arity >= 1 ? (strlen (operands[0]) + 1 ) : 0)
3163 + (arity >= 2 ? (strlen (operands[1]) + 1 ) : 0)
3164 + (arity >= 3 ? (strlen (operands[2]) + 0 ) : 0)
3165 + 1);
3166 assert (concat_string != NULL);
3168 /* Format the thing. */
3169 sprintf (concat_string,
3170 (arity == 0 ? "%s" :
3171 arity == 1 ? "%s:%s" :
3172 arity == 2 ? "%s:%s:%s" :
3173 /* arity == 3 */ "%s:%s:%s:%s"),
3174 opstr, operands[0], operands[1], operands[2]);
3177 /* Free operand strings (not opstr). */
3178 if (arity >= 1) xfree (operands[0]);
3179 if (arity >= 2) xfree (operands[1]);
3180 if (arity >= 3) xfree (operands[2]);
3182 return concat_string;
3185 #endif