Banish PARAMS and PTR. Convert to ISO C.
[binutils.git] / gas / symbols.c
blob30207109a300504ef01cbb9831558bf5e3eec7c8
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 = (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 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 = (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 = 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;
599 orgsymP->sy_previous = orgsymP->sy_next = orgsymP;
600 debug_verify_symchain (symbol_rootP, symbol_lastP);
602 symbol_table_insert (newsymP);
604 else
605 newsymP->sy_previous = newsymP->sy_next = newsymP;
607 return newsymP;
610 /* Referenced symbols, if they are forward references, need to be cloned
611 (without replacing the original) so that the value of the referenced
612 symbols at the point of use . */
614 #undef symbol_clone_if_forward_ref
615 symbolS *
616 symbol_clone_if_forward_ref (symbolS *symbolP, int is_forward)
618 if (symbolP && !LOCAL_SYMBOL_CHECK (symbolP))
620 symbolS *add_symbol = symbolP->sy_value.X_add_symbol;
621 symbolS *op_symbol = symbolP->sy_value.X_op_symbol;
623 if (symbolP->sy_forward_ref)
624 is_forward = 1;
626 if (is_forward)
628 /* assign_symbol() clones volatile symbols; pre-existing expressions
629 hold references to the original instance, but want the current
630 value. Just repeat the lookup. */
631 if (add_symbol && S_IS_VOLATILE (add_symbol))
632 add_symbol = symbol_find_exact (S_GET_NAME (add_symbol));
633 if (op_symbol && S_IS_VOLATILE (op_symbol))
634 op_symbol = symbol_find_exact (S_GET_NAME (op_symbol));
637 /* Re-using sy_resolving here, as this routine cannot get called from
638 symbol resolution code. */
639 if (symbolP->bsym->section == expr_section && !symbolP->sy_resolving)
641 symbolP->sy_resolving = 1;
642 add_symbol = symbol_clone_if_forward_ref (add_symbol, is_forward);
643 op_symbol = symbol_clone_if_forward_ref (op_symbol, is_forward);
644 symbolP->sy_resolving = 0;
647 if (symbolP->sy_forward_ref
648 || add_symbol != symbolP->sy_value.X_add_symbol
649 || op_symbol != symbolP->sy_value.X_op_symbol)
650 symbolP = symbol_clone (symbolP, 0);
652 symbolP->sy_value.X_add_symbol = add_symbol;
653 symbolP->sy_value.X_op_symbol = op_symbol;
656 return symbolP;
659 symbolS *
660 symbol_temp_new (segT seg, valueT ofs, fragS *frag)
662 return symbol_new (FAKE_LABEL_NAME, seg, ofs, frag);
665 symbolS *
666 symbol_temp_new_now (void)
668 return symbol_temp_new (now_seg, frag_now_fix (), frag_now);
671 symbolS *
672 symbol_temp_make (void)
674 return symbol_make (FAKE_LABEL_NAME);
677 /* Implement symbol table lookup.
678 In: A symbol's name as a string: '\0' can't be part of a symbol name.
679 Out: NULL if the name was not in the symbol table, else the address
680 of a struct symbol associated with that name. */
682 symbolS *
683 symbol_find_exact (const char *name)
685 return symbol_find_exact_noref (name, 0);
688 symbolS *
689 symbol_find_exact_noref (const char *name, int noref)
691 struct local_symbol *locsym;
692 symbolS* sym;
694 locsym = (struct local_symbol *) hash_find (local_hash, name);
695 if (locsym != NULL)
696 return (symbolS *) locsym;
698 sym = ((symbolS *) hash_find (sy_hash, name));
700 /* Any references to the symbol, except for the reference in
701 .weakref, must clear this flag, such that the symbol does not
702 turn into a weak symbol. Note that we don't have to handle the
703 local_symbol case, since a weakrefd is always promoted out of the
704 local_symbol table when it is turned into a weak symbol. */
705 if (sym && ! noref)
706 S_CLEAR_WEAKREFD (sym);
708 return sym;
711 symbolS *
712 symbol_find (const char *name)
714 return symbol_find_noref (name, 0);
717 symbolS *
718 symbol_find_noref (const char *name, int noref)
720 #ifdef tc_canonicalize_symbol_name
722 char *copy;
723 size_t len = strlen (name) + 1;
725 copy = (char *) alloca (len);
726 memcpy (copy, name, len);
727 name = tc_canonicalize_symbol_name (copy);
729 #endif
731 if (! symbols_case_sensitive)
733 char *copy;
734 const char *orig;
735 unsigned char c;
737 orig = name;
738 name = copy = (char *) alloca (strlen (name) + 1);
740 while ((c = *orig++) != '\0')
742 *copy++ = TOUPPER (c);
744 *copy = '\0';
747 return symbol_find_exact_noref (name, noref);
750 /* Once upon a time, symbols were kept in a singly linked list. At
751 least coff needs to be able to rearrange them from time to time, for
752 which a doubly linked list is much more convenient. Loic did these
753 as macros which seemed dangerous to me so they're now functions.
754 xoxorich. */
756 /* Link symbol ADDME after symbol TARGET in the chain. */
758 void
759 symbol_append (symbolS *addme, symbolS *target,
760 symbolS **rootPP, symbolS **lastPP)
762 if (LOCAL_SYMBOL_CHECK (addme))
763 abort ();
764 if (target != NULL && LOCAL_SYMBOL_CHECK (target))
765 abort ();
767 if (target == NULL)
769 know (*rootPP == NULL);
770 know (*lastPP == NULL);
771 addme->sy_next = NULL;
772 addme->sy_previous = NULL;
773 *rootPP = addme;
774 *lastPP = addme;
775 return;
776 } /* if the list is empty */
778 if (target->sy_next != NULL)
780 target->sy_next->sy_previous = addme;
782 else
784 know (*lastPP == target);
785 *lastPP = addme;
786 } /* if we have a next */
788 addme->sy_next = target->sy_next;
789 target->sy_next = addme;
790 addme->sy_previous = target;
792 debug_verify_symchain (symbol_rootP, symbol_lastP);
795 /* Set the chain pointers of SYMBOL to null. */
797 void
798 symbol_clear_list_pointers (symbolS *symbolP)
800 if (LOCAL_SYMBOL_CHECK (symbolP))
801 abort ();
802 symbolP->sy_next = NULL;
803 symbolP->sy_previous = NULL;
806 /* Remove SYMBOLP from the list. */
808 void
809 symbol_remove (symbolS *symbolP, symbolS **rootPP, symbolS **lastPP)
811 if (LOCAL_SYMBOL_CHECK (symbolP))
812 abort ();
814 if (symbolP == *rootPP)
816 *rootPP = symbolP->sy_next;
817 } /* if it was the root */
819 if (symbolP == *lastPP)
821 *lastPP = symbolP->sy_previous;
822 } /* if it was the tail */
824 if (symbolP->sy_next != NULL)
826 symbolP->sy_next->sy_previous = symbolP->sy_previous;
827 } /* if not last */
829 if (symbolP->sy_previous != NULL)
831 symbolP->sy_previous->sy_next = symbolP->sy_next;
832 } /* if not first */
834 debug_verify_symchain (*rootPP, *lastPP);
837 /* Link symbol ADDME before symbol TARGET in the chain. */
839 void
840 symbol_insert (symbolS *addme, symbolS *target,
841 symbolS **rootPP, symbolS **lastPP ATTRIBUTE_UNUSED)
843 if (LOCAL_SYMBOL_CHECK (addme))
844 abort ();
845 if (LOCAL_SYMBOL_CHECK (target))
846 abort ();
848 if (target->sy_previous != NULL)
850 target->sy_previous->sy_next = addme;
852 else
854 know (*rootPP == target);
855 *rootPP = addme;
856 } /* if not first */
858 addme->sy_previous = target->sy_previous;
859 target->sy_previous = addme;
860 addme->sy_next = target;
862 debug_verify_symchain (*rootPP, *lastPP);
865 void
866 verify_symbol_chain (symbolS *rootP, symbolS *lastP)
868 symbolS *symbolP = rootP;
870 if (symbolP == NULL)
871 return;
873 for (; symbol_next (symbolP) != NULL; symbolP = symbol_next (symbolP))
875 assert (symbolP->bsym != NULL);
876 assert (symbolP->sy_next->sy_previous == symbolP);
879 assert (lastP == symbolP);
882 #ifdef OBJ_COMPLEX_RELC
884 static int
885 use_complex_relocs_for (symbolS * symp)
887 switch (symp->sy_value.X_op)
889 case O_constant:
890 return 0;
892 case O_symbol:
893 case O_symbol_rva:
894 case O_uminus:
895 case O_bit_not:
896 case O_logical_not:
897 if ( (S_IS_COMMON (symp->sy_value.X_add_symbol)
898 || S_IS_LOCAL (symp->sy_value.X_add_symbol))
900 (S_IS_DEFINED (symp->sy_value.X_add_symbol)
901 && S_GET_SEGMENT (symp->sy_value.X_add_symbol) != expr_section))
902 return 0;
903 break;
905 case O_multiply:
906 case O_divide:
907 case O_modulus:
908 case O_left_shift:
909 case O_right_shift:
910 case O_bit_inclusive_or:
911 case O_bit_or_not:
912 case O_bit_exclusive_or:
913 case O_bit_and:
914 case O_add:
915 case O_subtract:
916 case O_eq:
917 case O_ne:
918 case O_lt:
919 case O_le:
920 case O_ge:
921 case O_gt:
922 case O_logical_and:
923 case O_logical_or:
925 if ( (S_IS_COMMON (symp->sy_value.X_add_symbol)
926 || S_IS_LOCAL (symp->sy_value.X_add_symbol))
928 (S_IS_COMMON (symp->sy_value.X_op_symbol)
929 || S_IS_LOCAL (symp->sy_value.X_op_symbol))
931 && S_IS_DEFINED (symp->sy_value.X_add_symbol)
932 && S_IS_DEFINED (symp->sy_value.X_op_symbol)
933 && S_GET_SEGMENT (symp->sy_value.X_add_symbol) != expr_section
934 && S_GET_SEGMENT (symp->sy_value.X_op_symbol) != expr_section)
935 return 0;
936 break;
938 default:
939 break;
941 return 1;
943 #endif
945 static void
946 report_op_error (symbolS *symp, symbolS *left, symbolS *right)
948 char *file;
949 unsigned int line;
950 segT seg_left = S_GET_SEGMENT (left);
951 segT seg_right = right ? S_GET_SEGMENT (right) : 0;
953 if (expr_symbol_where (symp, &file, &line))
955 if (seg_left == undefined_section)
956 as_bad_where (file, line,
957 _("undefined symbol `%s' in operation"),
958 S_GET_NAME (left));
959 if (seg_right == undefined_section)
960 as_bad_where (file, line,
961 _("undefined symbol `%s' in operation"),
962 S_GET_NAME (right));
963 if (seg_left != undefined_section
964 && seg_right != undefined_section)
966 if (right)
967 as_bad_where (file, line,
968 _("invalid sections for operation on `%s' and `%s'"),
969 S_GET_NAME (left), S_GET_NAME (right));
970 else
971 as_bad_where (file, line,
972 _("invalid section for operation on `%s'"),
973 S_GET_NAME (left));
977 else
979 if (seg_left == undefined_section)
980 as_bad (_("undefined symbol `%s' in operation setting `%s'"),
981 S_GET_NAME (left), S_GET_NAME (symp));
982 if (seg_right == undefined_section)
983 as_bad (_("undefined symbol `%s' in operation setting `%s'"),
984 S_GET_NAME (right), S_GET_NAME (symp));
985 if (seg_left != undefined_section
986 && seg_right != undefined_section)
988 if (right)
989 as_bad (_("invalid sections for operation on `%s' and `%s' setting `%s'"),
990 S_GET_NAME (left), S_GET_NAME (right), S_GET_NAME (symp));
991 else
992 as_bad (_("invalid section for operation on `%s' setting `%s'"),
993 S_GET_NAME (left), S_GET_NAME (symp));
998 /* Resolve the value of a symbol. This is called during the final
999 pass over the symbol table to resolve any symbols with complex
1000 values. */
1002 valueT
1003 resolve_symbol_value (symbolS *symp)
1005 int resolved;
1006 valueT final_val = 0;
1007 segT final_seg;
1009 if (LOCAL_SYMBOL_CHECK (symp))
1011 struct local_symbol *locsym = (struct local_symbol *) symp;
1013 final_val = locsym->lsy_value;
1014 if (local_symbol_resolved_p (locsym))
1015 return final_val;
1017 final_val += local_symbol_get_frag (locsym)->fr_address / OCTETS_PER_BYTE;
1019 if (finalize_syms)
1021 locsym->lsy_value = final_val;
1022 local_symbol_mark_resolved (locsym);
1025 return final_val;
1028 if (symp->sy_resolved)
1030 if (symp->sy_value.X_op == O_constant)
1031 return (valueT) symp->sy_value.X_add_number;
1032 else
1033 return 0;
1036 resolved = 0;
1037 final_seg = S_GET_SEGMENT (symp);
1039 if (symp->sy_resolving)
1041 if (finalize_syms)
1042 as_bad (_("symbol definition loop encountered at `%s'"),
1043 S_GET_NAME (symp));
1044 final_val = 0;
1045 resolved = 1;
1047 #ifdef OBJ_COMPLEX_RELC
1048 else if (final_seg == expr_section
1049 && use_complex_relocs_for (symp))
1051 symbolS * relc_symbol = NULL;
1052 char * relc_symbol_name = NULL;
1054 relc_symbol_name = symbol_relc_make_expr (& symp->sy_value);
1056 /* For debugging, print out conversion input & output. */
1057 #ifdef DEBUG_SYMS
1058 print_expr (& symp->sy_value);
1059 if (relc_symbol_name)
1060 fprintf (stderr, "-> relc symbol: %s\n", relc_symbol_name);
1061 #endif
1063 if (relc_symbol_name != NULL)
1064 relc_symbol = symbol_new (relc_symbol_name, undefined_section,
1065 0, & zero_address_frag);
1067 if (relc_symbol == NULL)
1069 as_bad (_("cannot convert expression symbol %s to complex relocation"),
1070 S_GET_NAME (symp));
1071 resolved = 0;
1073 else
1075 symbol_table_insert (relc_symbol);
1077 /* S_CLEAR_EXTERNAL (relc_symbol); */
1078 if (symp->bsym->flags & BSF_SRELC)
1079 relc_symbol->bsym->flags |= BSF_SRELC;
1080 else
1081 relc_symbol->bsym->flags |= BSF_RELC;
1082 /* symp->bsym->flags |= BSF_RELC; */
1083 copy_symbol_attributes (symp, relc_symbol);
1084 symp->sy_value.X_op = O_symbol;
1085 symp->sy_value.X_add_symbol = relc_symbol;
1086 symp->sy_value.X_add_number = 0;
1087 resolved = 1;
1090 final_seg = undefined_section;
1091 goto exit_dont_set_value;
1093 #endif
1094 else
1096 symbolS *add_symbol, *op_symbol;
1097 offsetT left, right;
1098 segT seg_left, seg_right;
1099 operatorT op;
1100 int move_seg_ok;
1102 symp->sy_resolving = 1;
1104 /* Help out with CSE. */
1105 add_symbol = symp->sy_value.X_add_symbol;
1106 op_symbol = symp->sy_value.X_op_symbol;
1107 final_val = symp->sy_value.X_add_number;
1108 op = symp->sy_value.X_op;
1110 switch (op)
1112 default:
1113 BAD_CASE (op);
1114 break;
1116 case O_absent:
1117 final_val = 0;
1118 /* Fall through. */
1120 case O_constant:
1121 final_val += symp->sy_frag->fr_address / OCTETS_PER_BYTE;
1122 if (final_seg == expr_section)
1123 final_seg = absolute_section;
1124 /* Fall through. */
1126 case O_register:
1127 resolved = 1;
1128 break;
1130 case O_symbol:
1131 case O_symbol_rva:
1132 left = resolve_symbol_value (add_symbol);
1133 seg_left = S_GET_SEGMENT (add_symbol);
1134 if (finalize_syms)
1135 symp->sy_value.X_op_symbol = NULL;
1137 do_symbol:
1138 if (S_IS_WEAKREFR (symp))
1140 assert (final_val == 0);
1141 if (S_IS_WEAKREFR (add_symbol))
1143 assert (add_symbol->sy_value.X_op == O_symbol
1144 && add_symbol->sy_value.X_add_number == 0);
1145 add_symbol = add_symbol->sy_value.X_add_symbol;
1146 assert (! S_IS_WEAKREFR (add_symbol));
1147 symp->sy_value.X_add_symbol = add_symbol;
1151 if (symp->sy_mri_common)
1153 /* This is a symbol inside an MRI common section. The
1154 relocation routines are going to handle it specially.
1155 Don't change the value. */
1156 resolved = symbol_resolved_p (add_symbol);
1157 break;
1160 if (finalize_syms && final_val == 0)
1162 if (LOCAL_SYMBOL_CHECK (add_symbol))
1163 add_symbol = local_symbol_convert ((struct local_symbol *)
1164 add_symbol);
1165 copy_symbol_attributes (symp, add_symbol);
1168 /* If we have equated this symbol to an undefined or common
1169 symbol, keep X_op set to O_symbol, and don't change
1170 X_add_number. This permits the routine which writes out
1171 relocation to detect this case, and convert the
1172 relocation to be against the symbol to which this symbol
1173 is equated. */
1174 if (! S_IS_DEFINED (add_symbol)
1175 #if defined (OBJ_COFF) && defined (TE_PE)
1176 || S_IS_WEAK (add_symbol)
1177 #endif
1178 || S_IS_COMMON (add_symbol))
1180 if (finalize_syms)
1182 symp->sy_value.X_op = O_symbol;
1183 symp->sy_value.X_add_symbol = add_symbol;
1184 symp->sy_value.X_add_number = final_val;
1185 /* Use X_op_symbol as a flag. */
1186 symp->sy_value.X_op_symbol = add_symbol;
1187 final_seg = seg_left;
1189 final_val = 0;
1190 resolved = symbol_resolved_p (add_symbol);
1191 symp->sy_resolving = 0;
1192 goto exit_dont_set_value;
1194 else if (finalize_syms
1195 && ((final_seg == expr_section && seg_left != expr_section)
1196 || symbol_shadow_p (symp)))
1198 /* If the symbol is an expression symbol, do similarly
1199 as for undefined and common syms above. Handles
1200 "sym +/- expr" where "expr" cannot be evaluated
1201 immediately, and we want relocations to be against
1202 "sym", eg. because it is weak. */
1203 symp->sy_value.X_op = O_symbol;
1204 symp->sy_value.X_add_symbol = add_symbol;
1205 symp->sy_value.X_add_number = final_val;
1206 symp->sy_value.X_op_symbol = add_symbol;
1207 final_seg = seg_left;
1208 final_val += symp->sy_frag->fr_address + left;
1209 resolved = symbol_resolved_p (add_symbol);
1210 symp->sy_resolving = 0;
1211 goto exit_dont_set_value;
1213 else
1215 final_val += symp->sy_frag->fr_address + left;
1216 if (final_seg == expr_section || final_seg == undefined_section)
1217 final_seg = seg_left;
1220 resolved = symbol_resolved_p (add_symbol);
1221 if (S_IS_WEAKREFR (symp))
1222 goto exit_dont_set_value;
1223 break;
1225 case O_uminus:
1226 case O_bit_not:
1227 case O_logical_not:
1228 left = resolve_symbol_value (add_symbol);
1229 seg_left = S_GET_SEGMENT (add_symbol);
1231 /* By reducing these to the relevant dyadic operator, we get
1232 !S -> S == 0 permitted on anything,
1233 -S -> 0 - S only permitted on absolute
1234 ~S -> S ^ ~0 only permitted on absolute */
1235 if (op != O_logical_not && seg_left != absolute_section
1236 && finalize_syms)
1237 report_op_error (symp, add_symbol, NULL);
1239 if (final_seg == expr_section || final_seg == undefined_section)
1240 final_seg = absolute_section;
1242 if (op == O_uminus)
1243 left = -left;
1244 else if (op == O_logical_not)
1245 left = !left;
1246 else
1247 left = ~left;
1249 final_val += left + symp->sy_frag->fr_address;
1251 resolved = symbol_resolved_p (add_symbol);
1252 break;
1254 case O_multiply:
1255 case O_divide:
1256 case O_modulus:
1257 case O_left_shift:
1258 case O_right_shift:
1259 case O_bit_inclusive_or:
1260 case O_bit_or_not:
1261 case O_bit_exclusive_or:
1262 case O_bit_and:
1263 case O_add:
1264 case O_subtract:
1265 case O_eq:
1266 case O_ne:
1267 case O_lt:
1268 case O_le:
1269 case O_ge:
1270 case O_gt:
1271 case O_logical_and:
1272 case O_logical_or:
1273 left = resolve_symbol_value (add_symbol);
1274 right = resolve_symbol_value (op_symbol);
1275 seg_left = S_GET_SEGMENT (add_symbol);
1276 seg_right = S_GET_SEGMENT (op_symbol);
1278 /* Simplify addition or subtraction of a constant by folding the
1279 constant into X_add_number. */
1280 if (op == O_add)
1282 if (seg_right == absolute_section)
1284 final_val += right;
1285 goto do_symbol;
1287 else if (seg_left == absolute_section)
1289 final_val += left;
1290 add_symbol = op_symbol;
1291 left = right;
1292 seg_left = seg_right;
1293 goto do_symbol;
1296 else if (op == O_subtract)
1298 if (seg_right == absolute_section)
1300 final_val -= right;
1301 goto do_symbol;
1305 move_seg_ok = 1;
1306 /* Equality and non-equality tests are permitted on anything.
1307 Subtraction, and other comparison operators are permitted if
1308 both operands are in the same section. Otherwise, both
1309 operands must be absolute. We already handled the case of
1310 addition or subtraction of a constant above. This will
1311 probably need to be changed for an object file format which
1312 supports arbitrary expressions, such as IEEE-695. */
1313 if (!(seg_left == absolute_section
1314 && seg_right == absolute_section)
1315 && !(op == O_eq || op == O_ne)
1316 && !((op == O_subtract
1317 || op == O_lt || op == O_le || op == O_ge || op == O_gt)
1318 && seg_left == seg_right
1319 && (seg_left != undefined_section
1320 || add_symbol == op_symbol)))
1322 /* Don't emit messages unless we're finalizing the symbol value,
1323 otherwise we may get the same message multiple times. */
1324 if (finalize_syms)
1325 report_op_error (symp, add_symbol, op_symbol);
1326 /* However do not move the symbol into the absolute section
1327 if it cannot currently be resolved - this would confuse
1328 other parts of the assembler into believing that the
1329 expression had been evaluated to zero. */
1330 else
1331 move_seg_ok = 0;
1334 if (move_seg_ok
1335 && (final_seg == expr_section || final_seg == undefined_section))
1336 final_seg = absolute_section;
1338 /* Check for division by zero. */
1339 if ((op == O_divide || op == O_modulus) && right == 0)
1341 /* If seg_right is not absolute_section, then we've
1342 already issued a warning about using a bad symbol. */
1343 if (seg_right == absolute_section && finalize_syms)
1345 char *file;
1346 unsigned int line;
1348 if (expr_symbol_where (symp, &file, &line))
1349 as_bad_where (file, line, _("division by zero"));
1350 else
1351 as_bad (_("division by zero when setting `%s'"),
1352 S_GET_NAME (symp));
1355 right = 1;
1358 switch (symp->sy_value.X_op)
1360 case O_multiply: left *= right; break;
1361 case O_divide: left /= right; break;
1362 case O_modulus: left %= right; break;
1363 case O_left_shift: left <<= right; break;
1364 case O_right_shift: left >>= right; break;
1365 case O_bit_inclusive_or: left |= right; break;
1366 case O_bit_or_not: left |= ~right; break;
1367 case O_bit_exclusive_or: left ^= right; break;
1368 case O_bit_and: left &= right; break;
1369 case O_add: left += right; break;
1370 case O_subtract: left -= right; break;
1371 case O_eq:
1372 case O_ne:
1373 left = (left == right && seg_left == seg_right
1374 && (seg_left != undefined_section
1375 || add_symbol == op_symbol)
1376 ? ~ (offsetT) 0 : 0);
1377 if (symp->sy_value.X_op == O_ne)
1378 left = ~left;
1379 break;
1380 case O_lt: left = left < right ? ~ (offsetT) 0 : 0; break;
1381 case O_le: left = left <= right ? ~ (offsetT) 0 : 0; break;
1382 case O_ge: left = left >= right ? ~ (offsetT) 0 : 0; break;
1383 case O_gt: left = left > right ? ~ (offsetT) 0 : 0; break;
1384 case O_logical_and: left = left && right; break;
1385 case O_logical_or: left = left || right; break;
1386 default: abort ();
1389 final_val += symp->sy_frag->fr_address + left;
1390 if (final_seg == expr_section || final_seg == undefined_section)
1392 if (seg_left == undefined_section
1393 || seg_right == undefined_section)
1394 final_seg = undefined_section;
1395 else if (seg_left == absolute_section)
1396 final_seg = seg_right;
1397 else
1398 final_seg = seg_left;
1400 resolved = (symbol_resolved_p (add_symbol)
1401 && symbol_resolved_p (op_symbol));
1402 break;
1404 case O_big:
1405 case O_illegal:
1406 /* Give an error (below) if not in expr_section. We don't
1407 want to worry about expr_section symbols, because they
1408 are fictional (they are created as part of expression
1409 resolution), and any problems may not actually mean
1410 anything. */
1411 break;
1414 symp->sy_resolving = 0;
1417 if (finalize_syms)
1418 S_SET_VALUE (symp, final_val);
1420 exit_dont_set_value:
1421 /* Always set the segment, even if not finalizing the value.
1422 The segment is used to determine whether a symbol is defined. */
1423 S_SET_SEGMENT (symp, final_seg);
1425 /* Don't worry if we can't resolve an expr_section symbol. */
1426 if (finalize_syms)
1428 if (resolved)
1429 symp->sy_resolved = 1;
1430 else if (S_GET_SEGMENT (symp) != expr_section)
1432 as_bad (_("can't resolve value for symbol `%s'"),
1433 S_GET_NAME (symp));
1434 symp->sy_resolved = 1;
1438 return final_val;
1441 static void resolve_local_symbol (const char *, void *);
1443 /* A static function passed to hash_traverse. */
1445 static void
1446 resolve_local_symbol (const char *key ATTRIBUTE_UNUSED, void *value)
1448 if (value != NULL)
1449 resolve_symbol_value (value);
1452 /* Resolve all local symbols. */
1454 void
1455 resolve_local_symbol_values (void)
1457 hash_traverse (local_hash, resolve_local_symbol);
1460 /* Obtain the current value of a symbol without changing any
1461 sub-expressions used. */
1464 snapshot_symbol (symbolS **symbolPP, valueT *valueP, segT *segP, fragS **fragPP)
1466 symbolS *symbolP = *symbolPP;
1468 if (LOCAL_SYMBOL_CHECK (symbolP))
1470 struct local_symbol *locsym = (struct local_symbol *) symbolP;
1472 *valueP = locsym->lsy_value;
1473 *segP = locsym->lsy_section;
1474 *fragPP = local_symbol_get_frag (locsym);
1476 else
1478 expressionS expr = symbolP->sy_value;
1480 if (!symbolP->sy_resolved && expr.X_op != O_illegal)
1482 int resolved;
1484 if (symbolP->sy_resolving)
1485 return 0;
1486 symbolP->sy_resolving = 1;
1487 resolved = resolve_expression (&expr);
1488 symbolP->sy_resolving = 0;
1489 if (!resolved)
1490 return 0;
1492 switch (expr.X_op)
1494 case O_constant:
1495 case O_register:
1496 if (!symbol_equated_p (symbolP))
1497 break;
1498 /* Fall thru. */
1499 case O_symbol:
1500 case O_symbol_rva:
1501 symbolP = expr.X_add_symbol;
1502 break;
1503 default:
1504 return 0;
1508 /* Never change a defined symbol. */
1509 if (symbolP->bsym->section == undefined_section
1510 || symbolP->bsym->section == expr_section)
1511 *symbolPP = symbolP;
1512 *valueP = expr.X_add_number;
1513 *segP = symbolP->bsym->section;
1514 *fragPP = symbolP->sy_frag;
1516 if (*segP == expr_section)
1517 switch (expr.X_op)
1519 case O_constant: *segP = absolute_section; break;
1520 case O_register: *segP = reg_section; break;
1521 default: break;
1525 return 1;
1528 /* Dollar labels look like a number followed by a dollar sign. Eg, "42$".
1529 They are *really* local. That is, they go out of scope whenever we see a
1530 label that isn't local. Also, like fb labels, there can be multiple
1531 instances of a dollar label. Therefor, we name encode each instance with
1532 the instance number, keep a list of defined symbols separate from the real
1533 symbol table, and we treat these buggers as a sparse array. */
1535 static long *dollar_labels;
1536 static long *dollar_label_instances;
1537 static char *dollar_label_defines;
1538 static unsigned long dollar_label_count;
1539 static unsigned long dollar_label_max;
1542 dollar_label_defined (long label)
1544 long *i;
1546 know ((dollar_labels != NULL) || (dollar_label_count == 0));
1548 for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
1549 if (*i == label)
1550 return dollar_label_defines[i - dollar_labels];
1552 /* If we get here, label isn't defined. */
1553 return 0;
1556 static long
1557 dollar_label_instance (long label)
1559 long *i;
1561 know ((dollar_labels != NULL) || (dollar_label_count == 0));
1563 for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
1564 if (*i == label)
1565 return (dollar_label_instances[i - dollar_labels]);
1567 /* If we get here, we haven't seen the label before.
1568 Therefore its instance count is zero. */
1569 return 0;
1572 void
1573 dollar_label_clear (void)
1575 memset (dollar_label_defines, '\0', (unsigned int) dollar_label_count);
1578 #define DOLLAR_LABEL_BUMP_BY 10
1580 void
1581 define_dollar_label (long label)
1583 long *i;
1585 for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
1586 if (*i == label)
1588 ++dollar_label_instances[i - dollar_labels];
1589 dollar_label_defines[i - dollar_labels] = 1;
1590 return;
1593 /* If we get to here, we don't have label listed yet. */
1595 if (dollar_labels == NULL)
1597 dollar_labels = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long));
1598 dollar_label_instances = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long));
1599 dollar_label_defines = xmalloc (DOLLAR_LABEL_BUMP_BY);
1600 dollar_label_max = DOLLAR_LABEL_BUMP_BY;
1601 dollar_label_count = 0;
1603 else if (dollar_label_count == dollar_label_max)
1605 dollar_label_max += DOLLAR_LABEL_BUMP_BY;
1606 dollar_labels = (long *) xrealloc ((char *) dollar_labels,
1607 dollar_label_max * sizeof (long));
1608 dollar_label_instances = (long *) xrealloc ((char *) dollar_label_instances,
1609 dollar_label_max * sizeof (long));
1610 dollar_label_defines = xrealloc (dollar_label_defines, dollar_label_max);
1611 } /* if we needed to grow */
1613 dollar_labels[dollar_label_count] = label;
1614 dollar_label_instances[dollar_label_count] = 1;
1615 dollar_label_defines[dollar_label_count] = 1;
1616 ++dollar_label_count;
1619 /* Caller must copy returned name: we re-use the area for the next name.
1621 The mth occurence of label n: is turned into the symbol "Ln^Am"
1622 where n is the label number and m is the instance number. "L" makes
1623 it a label discarded unless debugging and "^A"('\1') ensures no
1624 ordinary symbol SHOULD get the same name as a local label
1625 symbol. The first "4:" is "L4^A1" - the m numbers begin at 1.
1627 fb labels get the same treatment, except that ^B is used in place
1628 of ^A. */
1630 char * /* Return local label name. */
1631 dollar_label_name (register long n, /* we just saw "n$:" : n a number. */
1632 register int augend /* 0 for current instance, 1 for new instance. */)
1634 long i;
1635 /* Returned to caller, then copied. Used for created names ("4f"). */
1636 static char symbol_name_build[24];
1637 register char *p;
1638 register char *q;
1639 char symbol_name_temporary[20]; /* Build up a number, BACKWARDS. */
1641 know (n >= 0);
1642 know (augend == 0 || augend == 1);
1643 p = symbol_name_build;
1644 #ifdef LOCAL_LABEL_PREFIX
1645 *p++ = LOCAL_LABEL_PREFIX;
1646 #endif
1647 *p++ = 'L';
1649 /* Next code just does sprintf( {}, "%d", n); */
1650 /* Label number. */
1651 q = symbol_name_temporary;
1652 for (*q++ = 0, i = n; i; ++q)
1654 *q = i % 10 + '0';
1655 i /= 10;
1657 while ((*p = *--q) != '\0')
1658 ++p;
1660 *p++ = DOLLAR_LABEL_CHAR; /* ^A */
1662 /* Instance number. */
1663 q = symbol_name_temporary;
1664 for (*q++ = 0, i = dollar_label_instance (n) + augend; i; ++q)
1666 *q = i % 10 + '0';
1667 i /= 10;
1669 while ((*p++ = *--q) != '\0');;
1671 /* The label, as a '\0' ended string, starts at symbol_name_build. */
1672 return symbol_name_build;
1675 /* Somebody else's idea of local labels. They are made by "n:" where n
1676 is any decimal digit. Refer to them with
1677 "nb" for previous (backward) n:
1678 or "nf" for next (forward) n:.
1680 We do a little better and let n be any number, not just a single digit, but
1681 since the other guy's assembler only does ten, we treat the first ten
1682 specially.
1684 Like someone else's assembler, we have one set of local label counters for
1685 entire assembly, not one set per (sub)segment like in most assemblers. This
1686 implies that one can refer to a label in another segment, and indeed some
1687 crufty compilers have done just that.
1689 Since there could be a LOT of these things, treat them as a sparse
1690 array. */
1692 #define FB_LABEL_SPECIAL (10)
1694 static long fb_low_counter[FB_LABEL_SPECIAL];
1695 static long *fb_labels;
1696 static long *fb_label_instances;
1697 static long fb_label_count;
1698 static long fb_label_max;
1700 /* This must be more than FB_LABEL_SPECIAL. */
1701 #define FB_LABEL_BUMP_BY (FB_LABEL_SPECIAL + 6)
1703 static void
1704 fb_label_init (void)
1706 memset ((void *) fb_low_counter, '\0', sizeof (fb_low_counter));
1709 /* Add one to the instance number of this fb label. */
1711 void
1712 fb_label_instance_inc (long label)
1714 long *i;
1716 if (label < FB_LABEL_SPECIAL)
1718 ++fb_low_counter[label];
1719 return;
1722 if (fb_labels != NULL)
1724 for (i = fb_labels + FB_LABEL_SPECIAL;
1725 i < fb_labels + fb_label_count; ++i)
1727 if (*i == label)
1729 ++fb_label_instances[i - fb_labels];
1730 return;
1731 } /* if we find it */
1732 } /* for each existing label */
1735 /* If we get to here, we don't have label listed yet. */
1737 if (fb_labels == NULL)
1739 fb_labels = (long *) xmalloc (FB_LABEL_BUMP_BY * sizeof (long));
1740 fb_label_instances = (long *) xmalloc (FB_LABEL_BUMP_BY * sizeof (long));
1741 fb_label_max = FB_LABEL_BUMP_BY;
1742 fb_label_count = FB_LABEL_SPECIAL;
1745 else if (fb_label_count == fb_label_max)
1747 fb_label_max += FB_LABEL_BUMP_BY;
1748 fb_labels = (long *) xrealloc ((char *) fb_labels,
1749 fb_label_max * sizeof (long));
1750 fb_label_instances = (long *) xrealloc ((char *) fb_label_instances,
1751 fb_label_max * sizeof (long));
1752 } /* if we needed to grow */
1754 fb_labels[fb_label_count] = label;
1755 fb_label_instances[fb_label_count] = 1;
1756 ++fb_label_count;
1759 static long
1760 fb_label_instance (long label)
1762 long *i;
1764 if (label < FB_LABEL_SPECIAL)
1766 return (fb_low_counter[label]);
1769 if (fb_labels != NULL)
1771 for (i = fb_labels + FB_LABEL_SPECIAL;
1772 i < fb_labels + fb_label_count; ++i)
1774 if (*i == label)
1776 return (fb_label_instances[i - fb_labels]);
1777 } /* if we find it */
1778 } /* for each existing label */
1781 /* We didn't find the label, so this must be a reference to the
1782 first instance. */
1783 return 0;
1786 /* Caller must copy returned name: we re-use the area for the next name.
1788 The mth occurence of label n: is turned into the symbol "Ln^Bm"
1789 where n is the label number and m is the instance number. "L" makes
1790 it a label discarded unless debugging and "^B"('\2') ensures no
1791 ordinary symbol SHOULD get the same name as a local label
1792 symbol. The first "4:" is "L4^B1" - the m numbers begin at 1.
1794 dollar labels get the same treatment, except that ^A is used in
1795 place of ^B. */
1797 char * /* Return local label name. */
1798 fb_label_name (long n, /* We just saw "n:", "nf" or "nb" : n a number. */
1799 long augend /* 0 for nb, 1 for n:, nf. */)
1801 long i;
1802 /* Returned to caller, then copied. Used for created names ("4f"). */
1803 static char symbol_name_build[24];
1804 register char *p;
1805 register char *q;
1806 char symbol_name_temporary[20]; /* Build up a number, BACKWARDS. */
1808 know (n >= 0);
1809 #ifdef TC_MMIX
1810 know ((unsigned long) augend <= 2 /* See mmix_fb_label. */);
1811 #else
1812 know ((unsigned long) augend <= 1);
1813 #endif
1814 p = symbol_name_build;
1815 #ifdef LOCAL_LABEL_PREFIX
1816 *p++ = LOCAL_LABEL_PREFIX;
1817 #endif
1818 *p++ = 'L';
1820 /* Next code just does sprintf( {}, "%d", n); */
1821 /* Label number. */
1822 q = symbol_name_temporary;
1823 for (*q++ = 0, i = n; i; ++q)
1825 *q = i % 10 + '0';
1826 i /= 10;
1828 while ((*p = *--q) != '\0')
1829 ++p;
1831 *p++ = LOCAL_LABEL_CHAR; /* ^B */
1833 /* Instance number. */
1834 q = symbol_name_temporary;
1835 for (*q++ = 0, i = fb_label_instance (n) + augend; i; ++q)
1837 *q = i % 10 + '0';
1838 i /= 10;
1840 while ((*p++ = *--q) != '\0');;
1842 /* The label, as a '\0' ended string, starts at symbol_name_build. */
1843 return (symbol_name_build);
1846 /* Decode name that may have been generated by foo_label_name() above.
1847 If the name wasn't generated by foo_label_name(), then return it
1848 unaltered. This is used for error messages. */
1850 char *
1851 decode_local_label_name (char *s)
1853 char *p;
1854 char *symbol_decode;
1855 int label_number;
1856 int instance_number;
1857 char *type;
1858 const char *message_format;
1859 int index = 0;
1861 #ifdef LOCAL_LABEL_PREFIX
1862 if (s[index] == LOCAL_LABEL_PREFIX)
1863 ++index;
1864 #endif
1866 if (s[index] != 'L')
1867 return s;
1869 for (label_number = 0, p = s + index + 1; ISDIGIT (*p); ++p)
1870 label_number = (10 * label_number) + *p - '0';
1872 if (*p == DOLLAR_LABEL_CHAR)
1873 type = "dollar";
1874 else if (*p == LOCAL_LABEL_CHAR)
1875 type = "fb";
1876 else
1877 return s;
1879 for (instance_number = 0, p++; ISDIGIT (*p); ++p)
1880 instance_number = (10 * instance_number) + *p - '0';
1882 message_format = _("\"%d\" (instance number %d of a %s label)");
1883 symbol_decode = obstack_alloc (&notes, strlen (message_format) + 30);
1884 sprintf (symbol_decode, message_format, label_number, instance_number, type);
1886 return symbol_decode;
1889 /* Get the value of a symbol. */
1891 valueT
1892 S_GET_VALUE (symbolS *s)
1894 if (LOCAL_SYMBOL_CHECK (s))
1895 return resolve_symbol_value (s);
1897 if (!s->sy_resolved)
1899 valueT val = resolve_symbol_value (s);
1900 if (!finalize_syms)
1901 return val;
1903 if (S_IS_WEAKREFR (s))
1904 return S_GET_VALUE (s->sy_value.X_add_symbol);
1906 if (s->sy_value.X_op != O_constant)
1908 if (! s->sy_resolved
1909 || s->sy_value.X_op != O_symbol
1910 || (S_IS_DEFINED (s) && ! S_IS_COMMON (s)))
1911 as_bad (_("attempt to get value of unresolved symbol `%s'"),
1912 S_GET_NAME (s));
1914 return (valueT) s->sy_value.X_add_number;
1917 /* Set the value of a symbol. */
1919 void
1920 S_SET_VALUE (symbolS *s, valueT val)
1922 if (LOCAL_SYMBOL_CHECK (s))
1924 ((struct local_symbol *) s)->lsy_value = val;
1925 return;
1928 s->sy_value.X_op = O_constant;
1929 s->sy_value.X_add_number = (offsetT) val;
1930 s->sy_value.X_unsigned = 0;
1931 S_CLEAR_WEAKREFR (s);
1934 void
1935 copy_symbol_attributes (symbolS *dest, symbolS *src)
1937 if (LOCAL_SYMBOL_CHECK (dest))
1938 dest = local_symbol_convert ((struct local_symbol *) dest);
1939 if (LOCAL_SYMBOL_CHECK (src))
1940 src = local_symbol_convert ((struct local_symbol *) src);
1942 /* In an expression, transfer the settings of these flags.
1943 The user can override later, of course. */
1944 #define COPIED_SYMFLAGS (BSF_FUNCTION | BSF_OBJECT)
1945 dest->bsym->flags |= src->bsym->flags & COPIED_SYMFLAGS;
1947 #ifdef OBJ_COPY_SYMBOL_ATTRIBUTES
1948 OBJ_COPY_SYMBOL_ATTRIBUTES (dest, src);
1949 #endif
1951 #ifdef TC_COPY_SYMBOL_ATTRIBUTES
1952 TC_COPY_SYMBOL_ATTRIBUTES (dest, src);
1953 #endif
1957 S_IS_FUNCTION (symbolS *s)
1959 flagword flags;
1961 if (LOCAL_SYMBOL_CHECK (s))
1962 return 0;
1964 flags = s->bsym->flags;
1966 return (flags & BSF_FUNCTION) != 0;
1970 S_IS_EXTERNAL (symbolS *s)
1972 flagword flags;
1974 if (LOCAL_SYMBOL_CHECK (s))
1975 return 0;
1977 flags = s->bsym->flags;
1979 /* Sanity check. */
1980 if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL))
1981 abort ();
1983 return (flags & BSF_GLOBAL) != 0;
1987 S_IS_WEAK (symbolS *s)
1989 if (LOCAL_SYMBOL_CHECK (s))
1990 return 0;
1991 /* Conceptually, a weakrefr is weak if the referenced symbol is. We
1992 could probably handle a WEAKREFR as always weak though. E.g., if
1993 the referenced symbol has lost its weak status, there's no reason
1994 to keep handling the weakrefr as if it was weak. */
1995 if (S_IS_WEAKREFR (s))
1996 return S_IS_WEAK (s->sy_value.X_add_symbol);
1997 return (s->bsym->flags & BSF_WEAK) != 0;
2001 S_IS_WEAKREFR (symbolS *s)
2003 if (LOCAL_SYMBOL_CHECK (s))
2004 return 0;
2005 return s->sy_weakrefr != 0;
2009 S_IS_WEAKREFD (symbolS *s)
2011 if (LOCAL_SYMBOL_CHECK (s))
2012 return 0;
2013 return s->sy_weakrefd != 0;
2017 S_IS_COMMON (symbolS *s)
2019 if (LOCAL_SYMBOL_CHECK (s))
2020 return 0;
2021 return bfd_is_com_section (s->bsym->section);
2025 S_IS_DEFINED (symbolS *s)
2027 if (LOCAL_SYMBOL_CHECK (s))
2028 return ((struct local_symbol *) s)->lsy_section != undefined_section;
2029 return s->bsym->section != undefined_section;
2033 #ifndef EXTERN_FORCE_RELOC
2034 #define EXTERN_FORCE_RELOC IS_ELF
2035 #endif
2037 /* Return true for symbols that should not be reduced to section
2038 symbols or eliminated from expressions, because they may be
2039 overridden by the linker. */
2041 S_FORCE_RELOC (symbolS *s, int strict)
2043 if (LOCAL_SYMBOL_CHECK (s))
2044 return ((struct local_symbol *) s)->lsy_section == undefined_section;
2046 return ((strict
2047 && ((s->bsym->flags & BSF_WEAK) != 0
2048 || (EXTERN_FORCE_RELOC
2049 && (s->bsym->flags & BSF_GLOBAL) != 0)))
2050 || s->bsym->section == undefined_section
2051 || bfd_is_com_section (s->bsym->section));
2055 S_IS_DEBUG (symbolS *s)
2057 if (LOCAL_SYMBOL_CHECK (s))
2058 return 0;
2059 if (s->bsym->flags & BSF_DEBUGGING)
2060 return 1;
2061 return 0;
2065 S_IS_LOCAL (symbolS *s)
2067 flagword flags;
2068 const char *name;
2070 if (LOCAL_SYMBOL_CHECK (s))
2071 return 1;
2073 flags = s->bsym->flags;
2075 /* Sanity check. */
2076 if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL))
2077 abort ();
2079 if (bfd_get_section (s->bsym) == reg_section)
2080 return 1;
2082 if (flag_strip_local_absolute
2083 /* Keep BSF_FILE symbols in order to allow debuggers to identify
2084 the source file even when the object file is stripped. */
2085 && (flags & (BSF_GLOBAL | BSF_FILE)) == 0
2086 && bfd_get_section (s->bsym) == absolute_section)
2087 return 1;
2089 name = S_GET_NAME (s);
2090 return (name != NULL
2091 && ! S_IS_DEBUG (s)
2092 && (strchr (name, DOLLAR_LABEL_CHAR)
2093 || strchr (name, LOCAL_LABEL_CHAR)
2094 || (! flag_keep_locals
2095 && (bfd_is_local_label (stdoutput, s->bsym)
2096 || (flag_mri
2097 && name[0] == '?'
2098 && name[1] == '?')))));
2102 S_IS_STABD (symbolS *s)
2104 return S_GET_NAME (s) == 0;
2108 S_IS_VOLATILE (const symbolS *s)
2110 if (LOCAL_SYMBOL_CHECK (s))
2111 return 0;
2112 return s->sy_volatile;
2116 S_IS_FORWARD_REF (const symbolS *s)
2118 if (LOCAL_SYMBOL_CHECK (s))
2119 return 0;
2120 return s->sy_forward_ref;
2123 const char *
2124 S_GET_NAME (symbolS *s)
2126 if (LOCAL_SYMBOL_CHECK (s))
2127 return ((struct local_symbol *) s)->lsy_name;
2128 return s->bsym->name;
2131 segT
2132 S_GET_SEGMENT (symbolS *s)
2134 if (LOCAL_SYMBOL_CHECK (s))
2135 return ((struct local_symbol *) s)->lsy_section;
2136 return s->bsym->section;
2139 void
2140 S_SET_SEGMENT (symbolS *s, segT seg)
2142 /* Don't reassign section symbols. The direct reason is to prevent seg
2143 faults assigning back to const global symbols such as *ABS*, but it
2144 shouldn't happen anyway. */
2146 if (LOCAL_SYMBOL_CHECK (s))
2148 if (seg == reg_section)
2149 s = local_symbol_convert ((struct local_symbol *) s);
2150 else
2152 ((struct local_symbol *) s)->lsy_section = seg;
2153 return;
2157 if (s->bsym->flags & BSF_SECTION_SYM)
2159 if (s->bsym->section != seg)
2160 abort ();
2162 else
2163 s->bsym->section = seg;
2166 void
2167 S_SET_EXTERNAL (symbolS *s)
2169 if (LOCAL_SYMBOL_CHECK (s))
2170 s = local_symbol_convert ((struct local_symbol *) s);
2171 if ((s->bsym->flags & BSF_WEAK) != 0)
2173 /* Let .weak override .global. */
2174 return;
2176 if (s->bsym->flags & BSF_SECTION_SYM)
2178 char * file;
2179 unsigned int line;
2181 /* Do not reassign section symbols. */
2182 as_where (& file, & line);
2183 as_warn_where (file, line,
2184 _("section symbols are already global"));
2185 return;
2187 if (S_GET_SEGMENT (s) == reg_section)
2189 as_bad ("can't make register symbol `%s' global",
2190 S_GET_NAME (s));
2191 return;
2193 s->bsym->flags |= BSF_GLOBAL;
2194 s->bsym->flags &= ~(BSF_LOCAL | BSF_WEAK);
2196 #ifdef USE_UNIQUE
2197 if (! an_external_name && S_GET_NAME(s)[0] != '.')
2198 an_external_name = S_GET_NAME (s);
2199 #endif
2202 void
2203 S_CLEAR_EXTERNAL (symbolS *s)
2205 if (LOCAL_SYMBOL_CHECK (s))
2206 return;
2207 if ((s->bsym->flags & BSF_WEAK) != 0)
2209 /* Let .weak override. */
2210 return;
2212 s->bsym->flags |= BSF_LOCAL;
2213 s->bsym->flags &= ~(BSF_GLOBAL | BSF_WEAK);
2216 void
2217 S_SET_WEAK (symbolS *s)
2219 if (LOCAL_SYMBOL_CHECK (s))
2220 s = local_symbol_convert ((struct local_symbol *) s);
2221 #ifdef obj_set_weak_hook
2222 obj_set_weak_hook (s);
2223 #endif
2224 s->bsym->flags |= BSF_WEAK;
2225 s->bsym->flags &= ~(BSF_GLOBAL | BSF_LOCAL);
2228 void
2229 S_SET_WEAKREFR (symbolS *s)
2231 if (LOCAL_SYMBOL_CHECK (s))
2232 s = local_symbol_convert ((struct local_symbol *) s);
2233 s->sy_weakrefr = 1;
2234 /* If the alias was already used, make sure we mark the target as
2235 used as well, otherwise it might be dropped from the symbol
2236 table. This may have unintended side effects if the alias is
2237 later redirected to another symbol, such as keeping the unused
2238 previous target in the symbol table. Since it will be weak, it's
2239 not a big deal. */
2240 if (s->sy_used)
2241 symbol_mark_used (s->sy_value.X_add_symbol);
2244 void
2245 S_CLEAR_WEAKREFR (symbolS *s)
2247 if (LOCAL_SYMBOL_CHECK (s))
2248 return;
2249 s->sy_weakrefr = 0;
2252 void
2253 S_SET_WEAKREFD (symbolS *s)
2255 if (LOCAL_SYMBOL_CHECK (s))
2256 s = local_symbol_convert ((struct local_symbol *) s);
2257 s->sy_weakrefd = 1;
2258 S_SET_WEAK (s);
2261 void
2262 S_CLEAR_WEAKREFD (symbolS *s)
2264 if (LOCAL_SYMBOL_CHECK (s))
2265 return;
2266 if (s->sy_weakrefd)
2268 s->sy_weakrefd = 0;
2269 /* If a weakref target symbol is weak, then it was never
2270 referenced directly before, not even in a .global directive,
2271 so decay it to local. If it remains undefined, it will be
2272 later turned into a global, like any other undefined
2273 symbol. */
2274 if (s->bsym->flags & BSF_WEAK)
2276 #ifdef obj_clear_weak_hook
2277 obj_clear_weak_hook (s);
2278 #endif
2279 s->bsym->flags &= ~BSF_WEAK;
2280 s->bsym->flags |= BSF_LOCAL;
2285 void
2286 S_SET_THREAD_LOCAL (symbolS *s)
2288 if (LOCAL_SYMBOL_CHECK (s))
2289 s = local_symbol_convert ((struct local_symbol *) s);
2290 if (bfd_is_com_section (s->bsym->section)
2291 && (s->bsym->flags & BSF_THREAD_LOCAL) != 0)
2292 return;
2293 s->bsym->flags |= BSF_THREAD_LOCAL;
2294 if ((s->bsym->flags & BSF_FUNCTION) != 0)
2295 as_bad (_("Accessing function `%s' as thread-local object"),
2296 S_GET_NAME (s));
2297 else if (! bfd_is_und_section (s->bsym->section)
2298 && (s->bsym->section->flags & SEC_THREAD_LOCAL) == 0)
2299 as_bad (_("Accessing `%s' as thread-local object"),
2300 S_GET_NAME (s));
2303 void
2304 S_SET_NAME (symbolS *s, const char *name)
2306 if (LOCAL_SYMBOL_CHECK (s))
2308 ((struct local_symbol *) s)->lsy_name = name;
2309 return;
2311 s->bsym->name = name;
2314 void
2315 S_SET_VOLATILE (symbolS *s)
2317 if (LOCAL_SYMBOL_CHECK (s))
2318 s = local_symbol_convert ((struct local_symbol *) s);
2319 s->sy_volatile = 1;
2322 void
2323 S_CLEAR_VOLATILE (symbolS *s)
2325 if (!LOCAL_SYMBOL_CHECK (s))
2326 s->sy_volatile = 0;
2329 void
2330 S_SET_FORWARD_REF (symbolS *s)
2332 if (LOCAL_SYMBOL_CHECK (s))
2333 s = local_symbol_convert ((struct local_symbol *) s);
2334 s->sy_forward_ref = 1;
2337 /* Return the previous symbol in a chain. */
2339 symbolS *
2340 symbol_previous (symbolS *s)
2342 if (LOCAL_SYMBOL_CHECK (s))
2343 abort ();
2344 return s->sy_previous;
2347 /* Return the next symbol in a chain. */
2349 symbolS *
2350 symbol_next (symbolS *s)
2352 if (LOCAL_SYMBOL_CHECK (s))
2353 abort ();
2354 return s->sy_next;
2357 /* Return a pointer to the value of a symbol as an expression. */
2359 expressionS *
2360 symbol_get_value_expression (symbolS *s)
2362 if (LOCAL_SYMBOL_CHECK (s))
2363 s = local_symbol_convert ((struct local_symbol *) s);
2364 return &s->sy_value;
2367 /* Set the value of a symbol to an expression. */
2369 void
2370 symbol_set_value_expression (symbolS *s, const expressionS *exp)
2372 if (LOCAL_SYMBOL_CHECK (s))
2373 s = local_symbol_convert ((struct local_symbol *) s);
2374 s->sy_value = *exp;
2375 S_CLEAR_WEAKREFR (s);
2378 /* Return a pointer to the X_add_number component of a symbol. */
2380 offsetT *
2381 symbol_X_add_number (symbolS *s)
2383 if (LOCAL_SYMBOL_CHECK (s))
2384 return (offsetT *) &((struct local_symbol *) s)->lsy_value;
2386 return &s->sy_value.X_add_number;
2389 /* Set the value of SYM to the current position in the current segment. */
2391 void
2392 symbol_set_value_now (symbolS *sym)
2394 S_SET_SEGMENT (sym, now_seg);
2395 S_SET_VALUE (sym, frag_now_fix ());
2396 symbol_set_frag (sym, frag_now);
2399 /* Set the frag of a symbol. */
2401 void
2402 symbol_set_frag (symbolS *s, fragS *f)
2404 if (LOCAL_SYMBOL_CHECK (s))
2406 local_symbol_set_frag ((struct local_symbol *) s, f);
2407 return;
2409 s->sy_frag = f;
2410 S_CLEAR_WEAKREFR (s);
2413 /* Return the frag of a symbol. */
2415 fragS *
2416 symbol_get_frag (symbolS *s)
2418 if (LOCAL_SYMBOL_CHECK (s))
2419 return local_symbol_get_frag ((struct local_symbol *) s);
2420 return s->sy_frag;
2423 /* Mark a symbol as having been used. */
2425 void
2426 symbol_mark_used (symbolS *s)
2428 if (LOCAL_SYMBOL_CHECK (s))
2429 return;
2430 s->sy_used = 1;
2431 if (S_IS_WEAKREFR (s))
2432 symbol_mark_used (s->sy_value.X_add_symbol);
2435 /* Clear the mark of whether a symbol has been used. */
2437 void
2438 symbol_clear_used (symbolS *s)
2440 if (LOCAL_SYMBOL_CHECK (s))
2441 s = local_symbol_convert ((struct local_symbol *) s);
2442 s->sy_used = 0;
2445 /* Return whether a symbol has been used. */
2448 symbol_used_p (symbolS *s)
2450 if (LOCAL_SYMBOL_CHECK (s))
2451 return 1;
2452 return s->sy_used;
2455 /* Mark a symbol as having been used in a reloc. */
2457 void
2458 symbol_mark_used_in_reloc (symbolS *s)
2460 if (LOCAL_SYMBOL_CHECK (s))
2461 s = local_symbol_convert ((struct local_symbol *) s);
2462 s->sy_used_in_reloc = 1;
2465 /* Clear the mark of whether a symbol has been used in a reloc. */
2467 void
2468 symbol_clear_used_in_reloc (symbolS *s)
2470 if (LOCAL_SYMBOL_CHECK (s))
2471 return;
2472 s->sy_used_in_reloc = 0;
2475 /* Return whether a symbol has been used in a reloc. */
2478 symbol_used_in_reloc_p (symbolS *s)
2480 if (LOCAL_SYMBOL_CHECK (s))
2481 return 0;
2482 return s->sy_used_in_reloc;
2485 /* Mark a symbol as an MRI common symbol. */
2487 void
2488 symbol_mark_mri_common (symbolS *s)
2490 if (LOCAL_SYMBOL_CHECK (s))
2491 s = local_symbol_convert ((struct local_symbol *) s);
2492 s->sy_mri_common = 1;
2495 /* Clear the mark of whether a symbol is an MRI common symbol. */
2497 void
2498 symbol_clear_mri_common (symbolS *s)
2500 if (LOCAL_SYMBOL_CHECK (s))
2501 return;
2502 s->sy_mri_common = 0;
2505 /* Return whether a symbol is an MRI common symbol. */
2508 symbol_mri_common_p (symbolS *s)
2510 if (LOCAL_SYMBOL_CHECK (s))
2511 return 0;
2512 return s->sy_mri_common;
2515 /* Mark a symbol as having been written. */
2517 void
2518 symbol_mark_written (symbolS *s)
2520 if (LOCAL_SYMBOL_CHECK (s))
2521 return;
2522 s->written = 1;
2525 /* Clear the mark of whether a symbol has been written. */
2527 void
2528 symbol_clear_written (symbolS *s)
2530 if (LOCAL_SYMBOL_CHECK (s))
2531 return;
2532 s->written = 0;
2535 /* Return whether a symbol has been written. */
2538 symbol_written_p (symbolS *s)
2540 if (LOCAL_SYMBOL_CHECK (s))
2541 return 0;
2542 return s->written;
2545 /* Mark a symbol has having been resolved. */
2547 void
2548 symbol_mark_resolved (symbolS *s)
2550 if (LOCAL_SYMBOL_CHECK (s))
2552 local_symbol_mark_resolved ((struct local_symbol *) s);
2553 return;
2555 s->sy_resolved = 1;
2558 /* Return whether a symbol has been resolved. */
2561 symbol_resolved_p (symbolS *s)
2563 if (LOCAL_SYMBOL_CHECK (s))
2564 return local_symbol_resolved_p ((struct local_symbol *) s);
2565 return s->sy_resolved;
2568 /* Return whether a symbol is a section symbol. */
2571 symbol_section_p (symbolS *s ATTRIBUTE_UNUSED)
2573 if (LOCAL_SYMBOL_CHECK (s))
2574 return 0;
2575 return (s->bsym->flags & BSF_SECTION_SYM) != 0;
2578 /* Return whether a symbol is equated to another symbol. */
2581 symbol_equated_p (symbolS *s)
2583 if (LOCAL_SYMBOL_CHECK (s))
2584 return 0;
2585 return s->sy_value.X_op == O_symbol;
2588 /* Return whether a symbol is equated to another symbol, and should be
2589 treated specially when writing out relocs. */
2592 symbol_equated_reloc_p (symbolS *s)
2594 if (LOCAL_SYMBOL_CHECK (s))
2595 return 0;
2596 /* X_op_symbol, normally not used for O_symbol, is set by
2597 resolve_symbol_value to flag expression syms that have been
2598 equated. */
2599 return (s->sy_value.X_op == O_symbol
2600 #if defined (OBJ_COFF) && defined (TE_PE)
2601 && ! S_IS_WEAK (s)
2602 #endif
2603 && ((s->sy_resolved && s->sy_value.X_op_symbol != NULL)
2604 || ! S_IS_DEFINED (s)
2605 || S_IS_COMMON (s)));
2608 /* Return whether a symbol has a constant value. */
2611 symbol_constant_p (symbolS *s)
2613 if (LOCAL_SYMBOL_CHECK (s))
2614 return 1;
2615 return s->sy_value.X_op == O_constant;
2618 /* Return whether a symbol was cloned and thus removed from the global
2619 symbol list. */
2622 symbol_shadow_p (symbolS *s)
2624 if (LOCAL_SYMBOL_CHECK (s))
2625 return 0;
2626 return s->sy_next == s;
2629 /* Return the BFD symbol for a symbol. */
2631 asymbol *
2632 symbol_get_bfdsym (symbolS *s)
2634 if (LOCAL_SYMBOL_CHECK (s))
2635 s = local_symbol_convert ((struct local_symbol *) s);
2636 return s->bsym;
2639 /* Set the BFD symbol for a symbol. */
2641 void
2642 symbol_set_bfdsym (symbolS *s, asymbol *bsym)
2644 if (LOCAL_SYMBOL_CHECK (s))
2645 s = local_symbol_convert ((struct local_symbol *) s);
2646 /* Usually, it is harmless to reset a symbol to a BFD section
2647 symbol. For example, obj_elf_change_section sets the BFD symbol
2648 of an old symbol with the newly created section symbol. But when
2649 we have multiple sections with the same name, the newly created
2650 section may have the same name as an old section. We check if the
2651 old symbol has been already marked as a section symbol before
2652 resetting it. */
2653 if ((s->bsym->flags & BSF_SECTION_SYM) == 0)
2654 s->bsym = bsym;
2655 /* else XXX - What do we do now ? */
2658 #ifdef OBJ_SYMFIELD_TYPE
2660 /* Get a pointer to the object format information for a symbol. */
2662 OBJ_SYMFIELD_TYPE *
2663 symbol_get_obj (symbolS *s)
2665 if (LOCAL_SYMBOL_CHECK (s))
2666 s = local_symbol_convert ((struct local_symbol *) s);
2667 return &s->sy_obj;
2670 /* Set the object format information for a symbol. */
2672 void
2673 symbol_set_obj (symbolS *s, OBJ_SYMFIELD_TYPE *o)
2675 if (LOCAL_SYMBOL_CHECK (s))
2676 s = local_symbol_convert ((struct local_symbol *) s);
2677 s->sy_obj = *o;
2680 #endif /* OBJ_SYMFIELD_TYPE */
2682 #ifdef TC_SYMFIELD_TYPE
2684 /* Get a pointer to the processor information for a symbol. */
2686 TC_SYMFIELD_TYPE *
2687 symbol_get_tc (symbolS *s)
2689 if (LOCAL_SYMBOL_CHECK (s))
2690 s = local_symbol_convert ((struct local_symbol *) s);
2691 return &s->sy_tc;
2694 /* Set the processor information for a symbol. */
2696 void
2697 symbol_set_tc (symbolS *s, TC_SYMFIELD_TYPE *o)
2699 if (LOCAL_SYMBOL_CHECK (s))
2700 s = local_symbol_convert ((struct local_symbol *) s);
2701 s->sy_tc = *o;
2704 #endif /* TC_SYMFIELD_TYPE */
2706 void
2707 symbol_begin (void)
2709 symbol_lastP = NULL;
2710 symbol_rootP = NULL; /* In case we have 0 symbols (!!) */
2711 sy_hash = hash_new ();
2712 local_hash = hash_new ();
2714 memset ((char *) (&abs_symbol), '\0', sizeof (abs_symbol));
2715 #if defined (EMIT_SECTION_SYMBOLS) || !defined (RELOC_REQUIRES_SYMBOL)
2716 abs_symbol.bsym = bfd_abs_section.symbol;
2717 #endif
2718 abs_symbol.sy_value.X_op = O_constant;
2719 abs_symbol.sy_frag = &zero_address_frag;
2721 if (LOCAL_LABELS_FB)
2722 fb_label_init ();
2725 int indent_level;
2727 /* Maximum indent level.
2728 Available for modification inside a gdb session. */
2729 static int max_indent_level = 8;
2731 void
2732 print_symbol_value_1 (FILE *file, symbolS *sym)
2734 const char *name = S_GET_NAME (sym);
2735 if (!name || !name[0])
2736 name = "(unnamed)";
2737 fprintf (file, "sym ");
2738 fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) sym));
2739 fprintf (file, " %s", name);
2741 if (LOCAL_SYMBOL_CHECK (sym))
2743 struct local_symbol *locsym = (struct local_symbol *) sym;
2745 if (local_symbol_get_frag (locsym) != & zero_address_frag
2746 && local_symbol_get_frag (locsym) != NULL)
2748 fprintf (file, " frag ");
2749 fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) local_symbol_get_frag (locsym)));
2751 if (local_symbol_resolved_p (locsym))
2752 fprintf (file, " resolved");
2753 fprintf (file, " local");
2755 else
2757 if (sym->sy_frag != &zero_address_frag)
2759 fprintf (file, " frag ");
2760 fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) sym->sy_frag));
2762 if (sym->written)
2763 fprintf (file, " written");
2764 if (sym->sy_resolved)
2765 fprintf (file, " resolved");
2766 else if (sym->sy_resolving)
2767 fprintf (file, " resolving");
2768 if (sym->sy_used_in_reloc)
2769 fprintf (file, " used-in-reloc");
2770 if (sym->sy_used)
2771 fprintf (file, " used");
2772 if (S_IS_LOCAL (sym))
2773 fprintf (file, " local");
2774 if (S_IS_EXTERNAL (sym))
2775 fprintf (file, " extern");
2776 if (S_IS_WEAK (sym))
2777 fprintf (file, " weak");
2778 if (S_IS_DEBUG (sym))
2779 fprintf (file, " debug");
2780 if (S_IS_DEFINED (sym))
2781 fprintf (file, " defined");
2783 if (S_IS_WEAKREFR (sym))
2784 fprintf (file, " weakrefr");
2785 if (S_IS_WEAKREFD (sym))
2786 fprintf (file, " weakrefd");
2787 fprintf (file, " %s", segment_name (S_GET_SEGMENT (sym)));
2788 if (symbol_resolved_p (sym))
2790 segT s = S_GET_SEGMENT (sym);
2792 if (s != undefined_section
2793 && s != expr_section)
2794 fprintf (file, " %lx", (unsigned long) S_GET_VALUE (sym));
2796 else if (indent_level < max_indent_level
2797 && S_GET_SEGMENT (sym) != undefined_section)
2799 indent_level++;
2800 fprintf (file, "\n%*s<", indent_level * 4, "");
2801 if (LOCAL_SYMBOL_CHECK (sym))
2802 fprintf (file, "constant %lx",
2803 (unsigned long) ((struct local_symbol *) sym)->lsy_value);
2804 else
2805 print_expr_1 (file, &sym->sy_value);
2806 fprintf (file, ">");
2807 indent_level--;
2809 fflush (file);
2812 void
2813 print_symbol_value (symbolS *sym)
2815 indent_level = 0;
2816 print_symbol_value_1 (stderr, sym);
2817 fprintf (stderr, "\n");
2820 static void
2821 print_binary (FILE *file, const char *name, expressionS *exp)
2823 indent_level++;
2824 fprintf (file, "%s\n%*s<", name, indent_level * 4, "");
2825 print_symbol_value_1 (file, exp->X_add_symbol);
2826 fprintf (file, ">\n%*s<", indent_level * 4, "");
2827 print_symbol_value_1 (file, exp->X_op_symbol);
2828 fprintf (file, ">");
2829 indent_level--;
2832 void
2833 print_expr_1 (FILE *file, expressionS *exp)
2835 fprintf (file, "expr ");
2836 fprintf_vma (file, (bfd_vma) ((bfd_hostptr_t) exp));
2837 fprintf (file, " ");
2838 switch (exp->X_op)
2840 case O_illegal:
2841 fprintf (file, "illegal");
2842 break;
2843 case O_absent:
2844 fprintf (file, "absent");
2845 break;
2846 case O_constant:
2847 fprintf (file, "constant %lx", (unsigned long) exp->X_add_number);
2848 break;
2849 case O_symbol:
2850 indent_level++;
2851 fprintf (file, "symbol\n%*s<", indent_level * 4, "");
2852 print_symbol_value_1 (file, exp->X_add_symbol);
2853 fprintf (file, ">");
2854 maybe_print_addnum:
2855 if (exp->X_add_number)
2856 fprintf (file, "\n%*s%lx", indent_level * 4, "",
2857 (unsigned long) exp->X_add_number);
2858 indent_level--;
2859 break;
2860 case O_register:
2861 fprintf (file, "register #%d", (int) exp->X_add_number);
2862 break;
2863 case O_big:
2864 fprintf (file, "big");
2865 break;
2866 case O_uminus:
2867 fprintf (file, "uminus -<");
2868 indent_level++;
2869 print_symbol_value_1 (file, exp->X_add_symbol);
2870 fprintf (file, ">");
2871 goto maybe_print_addnum;
2872 case O_bit_not:
2873 fprintf (file, "bit_not");
2874 break;
2875 case O_multiply:
2876 print_binary (file, "multiply", exp);
2877 break;
2878 case O_divide:
2879 print_binary (file, "divide", exp);
2880 break;
2881 case O_modulus:
2882 print_binary (file, "modulus", exp);
2883 break;
2884 case O_left_shift:
2885 print_binary (file, "lshift", exp);
2886 break;
2887 case O_right_shift:
2888 print_binary (file, "rshift", exp);
2889 break;
2890 case O_bit_inclusive_or:
2891 print_binary (file, "bit_ior", exp);
2892 break;
2893 case O_bit_exclusive_or:
2894 print_binary (file, "bit_xor", exp);
2895 break;
2896 case O_bit_and:
2897 print_binary (file, "bit_and", exp);
2898 break;
2899 case O_eq:
2900 print_binary (file, "eq", exp);
2901 break;
2902 case O_ne:
2903 print_binary (file, "ne", exp);
2904 break;
2905 case O_lt:
2906 print_binary (file, "lt", exp);
2907 break;
2908 case O_le:
2909 print_binary (file, "le", exp);
2910 break;
2911 case O_ge:
2912 print_binary (file, "ge", exp);
2913 break;
2914 case O_gt:
2915 print_binary (file, "gt", exp);
2916 break;
2917 case O_logical_and:
2918 print_binary (file, "logical_and", exp);
2919 break;
2920 case O_logical_or:
2921 print_binary (file, "logical_or", exp);
2922 break;
2923 case O_add:
2924 indent_level++;
2925 fprintf (file, "add\n%*s<", indent_level * 4, "");
2926 print_symbol_value_1 (file, exp->X_add_symbol);
2927 fprintf (file, ">\n%*s<", indent_level * 4, "");
2928 print_symbol_value_1 (file, exp->X_op_symbol);
2929 fprintf (file, ">");
2930 goto maybe_print_addnum;
2931 case O_subtract:
2932 indent_level++;
2933 fprintf (file, "subtract\n%*s<", indent_level * 4, "");
2934 print_symbol_value_1 (file, exp->X_add_symbol);
2935 fprintf (file, ">\n%*s<", indent_level * 4, "");
2936 print_symbol_value_1 (file, exp->X_op_symbol);
2937 fprintf (file, ">");
2938 goto maybe_print_addnum;
2939 default:
2940 fprintf (file, "{unknown opcode %d}", (int) exp->X_op);
2941 break;
2943 fflush (stdout);
2946 void
2947 print_expr (expressionS *exp)
2949 print_expr_1 (stderr, exp);
2950 fprintf (stderr, "\n");
2953 void
2954 symbol_print_statistics (FILE *file)
2956 hash_print_statistics (file, "symbol table", sy_hash);
2957 hash_print_statistics (file, "mini local symbol table", local_hash);
2958 fprintf (file, "%lu mini local symbols created, %lu converted\n",
2959 local_symbol_count, local_symbol_conversion_count);
2962 #ifdef OBJ_COMPLEX_RELC
2964 /* Convert given symbol to a new complex-relocation symbol name. This
2965 may be a recursive function, since it might be called for non-leaf
2966 nodes (plain symbols) in the expression tree. The caller owns the
2967 returning string, so should free it eventually. Errors are
2968 indicated via as_bad and a NULL return value. The given symbol
2969 is marked with sy_used_in_reloc. */
2971 char *
2972 symbol_relc_make_sym (symbolS * sym)
2974 char * terminal = NULL;
2975 const char * sname;
2976 char typetag;
2977 int sname_len;
2979 assert (sym != NULL);
2981 /* Recurse to symbol_relc_make_expr if this symbol
2982 is defined as an expression or a plain value. */
2983 if ( S_GET_SEGMENT (sym) == expr_section
2984 || S_GET_SEGMENT (sym) == absolute_section)
2985 return symbol_relc_make_expr (& sym->sy_value);
2987 /* This may be a "fake symbol" L0\001, referring to ".".
2988 Write out a special null symbol to refer to this position. */
2989 if (! strcmp (S_GET_NAME (sym), FAKE_LABEL_NAME))
2990 return xstrdup (".");
2992 /* We hope this is a plain leaf symbol. Construct the encoding
2993 as {S,s}II...:CCCCCCC....
2994 where 'S'/'s' means section symbol / plain symbol
2995 III is decimal for the symbol name length
2996 CCC is the symbol name itself. */
2997 symbol_mark_used_in_reloc (sym);
2999 sname = S_GET_NAME (sym);
3000 sname_len = strlen (sname);
3001 typetag = symbol_section_p (sym) ? 'S' : 's';
3003 terminal = xmalloc (1 /* S or s */
3004 + 8 /* sname_len in decimal */
3005 + 1 /* _ spacer */
3006 + sname_len /* name itself */
3007 + 1 /* \0 */ );
3009 sprintf (terminal, "%c%d:%s", typetag, sname_len, sname);
3010 return terminal;
3013 /* Convert given value to a new complex-relocation symbol name. This
3014 is a non-recursive function, since it is be called for leaf nodes
3015 (plain values) in the expression tree. The caller owns the
3016 returning string, so should free() it eventually. No errors. */
3018 char *
3019 symbol_relc_make_value (offsetT val)
3021 char * terminal = xmalloc (28); /* Enough for long long. */
3023 terminal[0] = '#';
3024 bfd_sprintf_vma (stdoutput, terminal + 1, val);
3025 return terminal;
3028 /* Convert given expression to a new complex-relocation symbol name.
3029 This is a recursive function, since it traverses the entire given
3030 expression tree. The caller owns the returning string, so should
3031 free() it eventually. Errors are indicated via as_bad() and a NULL
3032 return value. */
3034 char *
3035 symbol_relc_make_expr (expressionS * exp)
3037 char * opstr = NULL; /* Operator prefix string. */
3038 int arity = 0; /* Arity of this operator. */
3039 char * operands[3]; /* Up to three operands. */
3040 char * concat_string = NULL;
3042 operands[0] = operands[1] = operands[2] = NULL;
3044 assert (exp != NULL);
3046 /* Match known operators -> fill in opstr, arity, operands[] and fall
3047 through to construct subexpression fragments; may instead return
3048 string directly for leaf nodes. */
3050 /* See expr.h for the meaning of all these enums. Many operators
3051 have an unnatural arity (X_add_number implicitly added). The
3052 conversion logic expands them to explicit "+" subexpressions. */
3054 switch (exp->X_op)
3056 default:
3057 as_bad ("Unknown expression operator (enum %d)", exp->X_op);
3058 break;
3060 /* Leaf nodes. */
3061 case O_constant:
3062 return symbol_relc_make_value (exp->X_add_number);
3064 case O_symbol:
3065 if (exp->X_add_number)
3067 arity = 2;
3068 opstr = "+";
3069 operands[0] = symbol_relc_make_sym (exp->X_add_symbol);
3070 operands[1] = symbol_relc_make_value (exp->X_add_number);
3071 break;
3073 else
3074 return symbol_relc_make_sym (exp->X_add_symbol);
3076 /* Helper macros for nesting nodes. */
3078 #define HANDLE_XADD_OPT1(str_) \
3079 if (exp->X_add_number) \
3081 arity = 2; \
3082 opstr = "+:" str_; \
3083 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3084 operands[1] = symbol_relc_make_value (exp->X_add_number); \
3085 break; \
3087 else \
3089 arity = 1; \
3090 opstr = str_; \
3091 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3093 break
3095 #define HANDLE_XADD_OPT2(str_) \
3096 if (exp->X_add_number) \
3098 arity = 3; \
3099 opstr = "+:" str_; \
3100 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3101 operands[1] = symbol_relc_make_sym (exp->X_op_symbol); \
3102 operands[2] = symbol_relc_make_value (exp->X_add_number); \
3104 else \
3106 arity = 2; \
3107 opstr = str_; \
3108 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3109 operands[1] = symbol_relc_make_sym (exp->X_op_symbol); \
3111 break
3113 /* Nesting nodes. */
3115 case O_uminus: HANDLE_XADD_OPT1 ("0-");
3116 case O_bit_not: HANDLE_XADD_OPT1 ("~");
3117 case O_logical_not: HANDLE_XADD_OPT1 ("!");
3118 case O_multiply: HANDLE_XADD_OPT2 ("*");
3119 case O_divide: HANDLE_XADD_OPT2 ("/");
3120 case O_modulus: HANDLE_XADD_OPT2 ("%");
3121 case O_left_shift: HANDLE_XADD_OPT2 ("<<");
3122 case O_right_shift: HANDLE_XADD_OPT2 (">>");
3123 case O_bit_inclusive_or: HANDLE_XADD_OPT2 ("|");
3124 case O_bit_exclusive_or: HANDLE_XADD_OPT2 ("^");
3125 case O_bit_and: HANDLE_XADD_OPT2 ("&");
3126 case O_add: HANDLE_XADD_OPT2 ("+");
3127 case O_subtract: HANDLE_XADD_OPT2 ("-");
3128 case O_eq: HANDLE_XADD_OPT2 ("==");
3129 case O_ne: HANDLE_XADD_OPT2 ("!=");
3130 case O_lt: HANDLE_XADD_OPT2 ("<");
3131 case O_le: HANDLE_XADD_OPT2 ("<=");
3132 case O_ge: HANDLE_XADD_OPT2 (">=");
3133 case O_gt: HANDLE_XADD_OPT2 (">");
3134 case O_logical_and: HANDLE_XADD_OPT2 ("&&");
3135 case O_logical_or: HANDLE_XADD_OPT2 ("||");
3138 /* Validate & reject early. */
3139 if (arity >= 1 && ((operands[0] == NULL) || (strlen (operands[0]) == 0)))
3140 opstr = NULL;
3141 if (arity >= 2 && ((operands[1] == NULL) || (strlen (operands[1]) == 0)))
3142 opstr = NULL;
3143 if (arity >= 3 && ((operands[2] == NULL) || (strlen (operands[2]) == 0)))
3144 opstr = NULL;
3146 if (opstr == NULL)
3147 concat_string = NULL;
3148 else
3150 /* Allocate new string; include inter-operand padding gaps etc. */
3151 concat_string = xmalloc (strlen (opstr)
3153 + (arity >= 1 ? (strlen (operands[0]) + 1 ) : 0)
3154 + (arity >= 2 ? (strlen (operands[1]) + 1 ) : 0)
3155 + (arity >= 3 ? (strlen (operands[2]) + 0 ) : 0)
3156 + 1);
3157 assert (concat_string != NULL);
3159 /* Format the thing. */
3160 sprintf (concat_string,
3161 (arity == 0 ? "%s" :
3162 arity == 1 ? "%s:%s" :
3163 arity == 2 ? "%s:%s:%s" :
3164 /* arity == 3 */ "%s:%s:%s:%s"),
3165 opstr, operands[0], operands[1], operands[2]);
3168 /* Free operand strings (not opstr). */
3169 if (arity >= 1) xfree (operands[0]);
3170 if (arity >= 2) xfree (operands[1]);
3171 if (arity >= 3) xfree (operands[2]);
3173 return concat_string;
3176 #endif