gas/
[deliverable/binutils-gdb.git] / gas / symbols.c
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
4 Free Software Foundation, Inc.
5
6 This file is part of GAS, the GNU Assembler.
7
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later version.
12
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.
17
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. */
22
23 /* #define DEBUG_SYMS / * to debug symbol list maintenance. */
24
25 #include "as.h"
26
27 #include "safe-ctype.h"
28 #include "obstack.h" /* For "symbols.h" */
29 #include "subsegs.h"
30
31 #include "struc-symbol.h"
32
33 /* This is non-zero if symbols are case sensitive, which is the
34 default. */
35 int symbols_case_sensitive = 1;
36
37 #ifndef WORKING_DOT_WORD
38 extern int new_broken_words;
39 #endif
40
41 /* symbol-name => struct symbol pointer */
42 static struct hash_control *sy_hash;
43
44 /* Table of local symbols. */
45 static struct hash_control *local_hash;
46
47 /* Below are commented in "symbols.h". */
48 symbolS *symbol_rootP;
49 symbolS *symbol_lastP;
50 symbolS abs_symbol;
51
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
57
58 #define DOLLAR_LABEL_CHAR '\001'
59 #define LOCAL_LABEL_CHAR '\002'
60
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
67
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);
72
73 static void print_binary (FILE *, const char *, expressionS *);
74 static void report_op_error (symbolS *, symbolS *, symbolS *);
75
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.
79
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. */
84
85 symbolS *
86 symbol_new (const char *name, segT segment, valueT valu, fragS *frag)
87 {
88 symbolS *symbolP = symbol_create (name, segment, valu, frag);
89
90 /* Link to end of symbol chain. */
91 {
92 extern int symbol_table_frozen;
93 if (symbol_table_frozen)
94 abort ();
95 }
96 symbol_append (symbolP, symbol_lastP, &symbol_rootP, &symbol_lastP);
97
98 return symbolP;
99 }
100
101 /* Save a symbol name on a permanent obstack, and convert it according
102 to the object file format. */
103
104 static char *
105 save_symbol_name (const char *name)
106 {
107 unsigned int name_length;
108 char *ret;
109
110 name_length = strlen (name) + 1; /* +1 for \0. */
111 obstack_grow (&notes, name, name_length);
112 ret = obstack_finish (&notes);
113
114 #ifdef tc_canonicalize_symbol_name
115 ret = tc_canonicalize_symbol_name (ret);
116 #endif
117
118 if (! symbols_case_sensitive)
119 {
120 char *s;
121
122 for (s = ret; *s != '\0'; s++)
123 *s = TOUPPER (*s);
124 }
125
126 return ret;
127 }
128
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. */)
134 {
135 char *preserved_copy_of_name;
136 symbolS *symbolP;
137
138 preserved_copy_of_name = save_symbol_name (name);
139
140 symbolP = (symbolS *) obstack_alloc (&notes, sizeof (symbolS));
141
142 /* symbol must be born in some fixed state. This seems as good as any. */
143 memset (symbolP, 0, sizeof (symbolS));
144
145 symbolP->bsym = bfd_make_empty_symbol (stdoutput);
146 if (symbolP->bsym == NULL)
147 as_perror ("%s", "bfd_make_empty_symbol");
148 symbolP->bsym->udata.p = (PTR) symbolP;
149 S_SET_NAME (symbolP, preserved_copy_of_name);
150
151 S_SET_SEGMENT (symbolP, segment);
152 S_SET_VALUE (symbolP, valu);
153 symbol_clear_list_pointers (symbolP);
154
155 symbolP->sy_frag = frag;
156
157 obj_symbol_new_hook (symbolP);
158
159 #ifdef tc_symbol_new_hook
160 tc_symbol_new_hook (symbolP);
161 #endif
162
163 return symbolP;
164 }
165 \f
166
167 /* Local symbol support. If we can get away with it, we keep only a
168 small amount of information for local symbols. */
169
170 static symbolS *local_symbol_convert (struct local_symbol *);
171
172 /* Used for statistics. */
173
174 static unsigned long local_symbol_count;
175 static unsigned long local_symbol_conversion_count;
176
177 /* This macro is called with a symbol argument passed by reference.
178 It returns whether this is a local symbol. If necessary, it
179 changes its argument to the real symbol. */
180
181 #define LOCAL_SYMBOL_CHECK(s) \
182 (s->bsym == NULL \
183 ? (local_symbol_converted_p ((struct local_symbol *) s) \
184 ? (s = local_symbol_get_real_symbol ((struct local_symbol *) s), \
185 0) \
186 : 1) \
187 : 0)
188
189 /* Create a local symbol and insert it into the local hash table. */
190
191 static struct local_symbol *
192 local_symbol_make (const char *name, segT section, valueT value, fragS *frag)
193 {
194 char *name_copy;
195 struct local_symbol *ret;
196
197 ++local_symbol_count;
198
199 name_copy = save_symbol_name (name);
200
201 ret = (struct local_symbol *) obstack_alloc (&notes, sizeof *ret);
202 ret->lsy_marker = NULL;
203 ret->lsy_name = name_copy;
204 ret->lsy_section = section;
205 local_symbol_set_frag (ret, frag);
206 ret->lsy_value = value;
207
208 hash_jam (local_hash, name_copy, (PTR) ret);
209
210 return ret;
211 }
212
213 /* Convert a local symbol into a real symbol. Note that we do not
214 reclaim the space used by the local symbol. */
215
216 static symbolS *
217 local_symbol_convert (struct local_symbol *locsym)
218 {
219 symbolS *ret;
220
221 assert (locsym->lsy_marker == NULL);
222 if (local_symbol_converted_p (locsym))
223 return local_symbol_get_real_symbol (locsym);
224
225 ++local_symbol_conversion_count;
226
227 ret = symbol_new (locsym->lsy_name, locsym->lsy_section, locsym->lsy_value,
228 local_symbol_get_frag (locsym));
229
230 if (local_symbol_resolved_p (locsym))
231 ret->sy_resolved = 1;
232
233 /* Local symbols are always either defined or used. */
234 ret->sy_used = 1;
235
236 #ifdef TC_LOCAL_SYMFIELD_CONVERT
237 TC_LOCAL_SYMFIELD_CONVERT (locsym, ret);
238 #endif
239
240 symbol_table_insert (ret);
241
242 local_symbol_mark_converted (locsym);
243 local_symbol_set_real_symbol (locsym, ret);
244
245 hash_jam (local_hash, locsym->lsy_name, NULL);
246
247 return ret;
248 }
249 \f
250 /* We have just seen "<name>:".
251 Creates a struct symbol unless it already exists.
252
253 Gripes if we are redefining a symbol incompatibly (and ignores it). */
254
255 symbolS *
256 colon (/* Just seen "x:" - rattle symbols & frags. */
257 const char *sym_name /* Symbol name, as a cannonical string. */
258 /* We copy this string: OK to alter later. */)
259 {
260 register symbolS *symbolP; /* Symbol we are working with. */
261
262 /* Sun local labels go out of scope whenever a non-local symbol is
263 defined. */
264 if (LOCAL_LABELS_DOLLAR
265 && !bfd_is_local_label_name (stdoutput, sym_name))
266 dollar_label_clear ();
267
268 #ifndef WORKING_DOT_WORD
269 if (new_broken_words)
270 {
271 struct broken_word *a;
272 int possible_bytes;
273 fragS *frag_tmp;
274 char *frag_opcode;
275
276 if (now_seg == absolute_section)
277 {
278 as_bad (_("cannot define symbol `%s' in absolute section"), sym_name);
279 return NULL;
280 }
281
282 possible_bytes = (md_short_jump_size
283 + new_broken_words * md_long_jump_size);
284
285 frag_tmp = frag_now;
286 frag_opcode = frag_var (rs_broken_word,
287 possible_bytes,
288 possible_bytes,
289 (relax_substateT) 0,
290 (symbolS *) broken_words,
291 (offsetT) 0,
292 NULL);
293
294 /* We want to store the pointer to where to insert the jump
295 table in the fr_opcode of the rs_broken_word frag. This
296 requires a little hackery. */
297 while (frag_tmp
298 && (frag_tmp->fr_type != rs_broken_word
299 || frag_tmp->fr_opcode))
300 frag_tmp = frag_tmp->fr_next;
301 know (frag_tmp);
302 frag_tmp->fr_opcode = frag_opcode;
303 new_broken_words = 0;
304
305 for (a = broken_words; a && a->dispfrag == 0; a = a->next_broken_word)
306 a->dispfrag = frag_tmp;
307 }
308 #endif /* WORKING_DOT_WORD */
309
310 if ((symbolP = symbol_find (sym_name)) != 0)
311 {
312 S_CLEAR_WEAKREFR (symbolP);
313 #ifdef RESOLVE_SYMBOL_REDEFINITION
314 if (RESOLVE_SYMBOL_REDEFINITION (symbolP))
315 return symbolP;
316 #endif
317 /* Now check for undefined symbols. */
318 if (LOCAL_SYMBOL_CHECK (symbolP))
319 {
320 struct local_symbol *locsym = (struct local_symbol *) symbolP;
321
322 if (locsym->lsy_section != undefined_section
323 && (local_symbol_get_frag (locsym) != frag_now
324 || locsym->lsy_section != now_seg
325 || locsym->lsy_value != frag_now_fix ()))
326 {
327 as_bad (_("symbol `%s' is already defined"), sym_name);
328 return symbolP;
329 }
330
331 locsym->lsy_section = now_seg;
332 local_symbol_set_frag (locsym, frag_now);
333 locsym->lsy_value = frag_now_fix ();
334 }
335 else if (!(S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
336 || S_IS_COMMON (symbolP)
337 || S_IS_VOLATILE (symbolP))
338 {
339 if (S_IS_VOLATILE (symbolP)
340 /* This could be avoided when the symbol wasn't used so far, but
341 the comment in struc-symbol.h says this flag isn't reliable. */
342 && (1 || !symbol_used_p (symbolP)))
343 {
344 symbolP = symbol_clone (symbolP, 1);
345 S_SET_VALUE (symbolP, 0);
346 S_CLEAR_VOLATILE (symbolP);
347 }
348 if (S_GET_VALUE (symbolP) == 0)
349 {
350 symbolP->sy_frag = frag_now;
351 #ifdef OBJ_VMS
352 S_SET_OTHER (symbolP, const_flag);
353 #endif
354 S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
355 S_SET_SEGMENT (symbolP, now_seg);
356 #ifdef N_UNDF
357 know (N_UNDF == 0);
358 #endif /* if we have one, it better be zero. */
359
360 }
361 else
362 {
363 /* There are still several cases to check:
364
365 A .comm/.lcomm symbol being redefined as initialized
366 data is OK
367
368 A .comm/.lcomm symbol being redefined with a larger
369 size is also OK
370
371 This only used to be allowed on VMS gas, but Sun cc
372 on the sparc also depends on it. */
373
374 if (((!S_IS_DEBUG (symbolP)
375 && (!S_IS_DEFINED (symbolP) || S_IS_COMMON (symbolP))
376 && S_IS_EXTERNAL (symbolP))
377 || S_GET_SEGMENT (symbolP) == bss_section)
378 && (now_seg == data_section
379 || now_seg == bss_section
380 || now_seg == S_GET_SEGMENT (symbolP)))
381 {
382 /* Select which of the 2 cases this is. */
383 if (now_seg != data_section)
384 {
385 /* New .comm for prev .comm symbol.
386
387 If the new size is larger we just change its
388 value. If the new size is smaller, we ignore
389 this symbol. */
390 if (S_GET_VALUE (symbolP)
391 < ((unsigned) frag_now_fix ()))
392 {
393 S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
394 }
395 }
396 else
397 {
398 /* It is a .comm/.lcomm being converted to initialized
399 data. */
400 symbolP->sy_frag = frag_now;
401 #ifdef OBJ_VMS
402 S_SET_OTHER (symbolP, const_flag);
403 #endif
404 S_SET_VALUE (symbolP, (valueT) frag_now_fix ());
405 S_SET_SEGMENT (symbolP, now_seg); /* Keep N_EXT bit. */
406 }
407 }
408 else
409 {
410 #if (!defined (OBJ_AOUT) && !defined (OBJ_MAYBE_AOUT) \
411 && !defined (OBJ_BOUT) && !defined (OBJ_MAYBE_BOUT))
412 static const char *od_buf = "";
413 #else
414 char od_buf[100];
415 od_buf[0] = '\0';
416 if (OUTPUT_FLAVOR == bfd_target_aout_flavour)
417 sprintf (od_buf, "%d.%d.",
418 S_GET_OTHER (symbolP),
419 S_GET_DESC (symbolP));
420 #endif
421 as_bad (_("symbol `%s' is already defined as \"%s\"/%s%ld"),
422 sym_name,
423 segment_name (S_GET_SEGMENT (symbolP)),
424 od_buf,
425 (long) S_GET_VALUE (symbolP));
426 }
427 } /* if the undefined symbol has no value */
428 }
429 else
430 {
431 /* Don't blow up if the definition is the same. */
432 if (!(frag_now == symbolP->sy_frag
433 && S_GET_VALUE (symbolP) == frag_now_fix ()
434 && S_GET_SEGMENT (symbolP) == now_seg))
435 {
436 as_bad (_("symbol `%s' is already defined"), sym_name);
437 symbolP = symbol_clone (symbolP, 0);
438 }
439 }
440
441 }
442 else if (! flag_keep_locals && bfd_is_local_label_name (stdoutput, sym_name))
443 {
444 symbolP = (symbolS *) local_symbol_make (sym_name, now_seg,
445 (valueT) frag_now_fix (),
446 frag_now);
447 }
448 else
449 {
450 symbolP = symbol_new (sym_name, now_seg, (valueT) frag_now_fix (),
451 frag_now);
452 #ifdef OBJ_VMS
453 S_SET_OTHER (symbolP, const_flag);
454 #endif /* OBJ_VMS */
455
456 symbol_table_insert (symbolP);
457 }
458
459 if (mri_common_symbol != NULL)
460 {
461 /* This symbol is actually being defined within an MRI common
462 section. This requires special handling. */
463 if (LOCAL_SYMBOL_CHECK (symbolP))
464 symbolP = local_symbol_convert ((struct local_symbol *) symbolP);
465 symbolP->sy_value.X_op = O_symbol;
466 symbolP->sy_value.X_add_symbol = mri_common_symbol;
467 symbolP->sy_value.X_add_number = S_GET_VALUE (mri_common_symbol);
468 symbolP->sy_frag = &zero_address_frag;
469 S_SET_SEGMENT (symbolP, expr_section);
470 symbolP->sy_mri_common = 1;
471 }
472
473 #ifdef tc_frob_label
474 tc_frob_label (symbolP);
475 #endif
476 #ifdef obj_frob_label
477 obj_frob_label (symbolP);
478 #endif
479
480 return symbolP;
481 }
482 \f
483 /* Die if we can't insert the symbol. */
484
485 void
486 symbol_table_insert (symbolS *symbolP)
487 {
488 register const char *error_string;
489
490 know (symbolP);
491 know (S_GET_NAME (symbolP));
492
493 if (LOCAL_SYMBOL_CHECK (symbolP))
494 {
495 error_string = hash_jam (local_hash, S_GET_NAME (symbolP),
496 (PTR) symbolP);
497 if (error_string != NULL)
498 as_fatal (_("inserting \"%s\" into symbol table failed: %s"),
499 S_GET_NAME (symbolP), error_string);
500 return;
501 }
502
503 if ((error_string = hash_jam (sy_hash, S_GET_NAME (symbolP), (PTR) symbolP)))
504 {
505 as_fatal (_("inserting \"%s\" into symbol table failed: %s"),
506 S_GET_NAME (symbolP), error_string);
507 } /* on error */
508 }
509 \f
510 /* If a symbol name does not exist, create it as undefined, and insert
511 it into the symbol table. Return a pointer to it. */
512
513 symbolS *
514 symbol_find_or_make (const char *name)
515 {
516 register symbolS *symbolP;
517
518 symbolP = symbol_find (name);
519
520 if (symbolP == NULL)
521 {
522 if (! flag_keep_locals && bfd_is_local_label_name (stdoutput, name))
523 {
524 symbolP = md_undefined_symbol ((char *) name);
525 if (symbolP != NULL)
526 return symbolP;
527
528 symbolP = (symbolS *) local_symbol_make (name, undefined_section,
529 (valueT) 0,
530 &zero_address_frag);
531 return symbolP;
532 }
533
534 symbolP = symbol_make (name);
535
536 symbol_table_insert (symbolP);
537 } /* if symbol wasn't found */
538
539 return (symbolP);
540 }
541
542 symbolS *
543 symbol_make (const char *name)
544 {
545 symbolS *symbolP;
546
547 /* Let the machine description default it, e.g. for register names. */
548 symbolP = md_undefined_symbol ((char *) name);
549
550 if (!symbolP)
551 symbolP = symbol_new (name, undefined_section, (valueT) 0, &zero_address_frag);
552
553 return (symbolP);
554 }
555
556 symbolS *
557 symbol_clone (symbolS *orgsymP, int replace)
558 {
559 symbolS *newsymP;
560 asymbol *bsymorg, *bsymnew;
561
562 /* Running local_symbol_convert on a clone that's not the one currently
563 in local_hash would incorrectly replace the hash entry. Thus the
564 symbol must be converted here. Note that the rest of the function
565 depends on not encountering an unconverted symbol. */
566 if (LOCAL_SYMBOL_CHECK (orgsymP))
567 orgsymP = local_symbol_convert ((struct local_symbol *) orgsymP);
568 bsymorg = orgsymP->bsym;
569
570 know (S_IS_DEFINED (orgsymP));
571
572 newsymP = obstack_alloc (&notes, sizeof (*newsymP));
573 *newsymP = *orgsymP;
574 bsymnew = bfd_make_empty_symbol (bfd_asymbol_bfd (bsymorg));
575 if (bsymnew == NULL)
576 as_perror ("%s", "bfd_make_empty_symbol");
577 newsymP->bsym = bsymnew;
578 bsymnew->name = bsymorg->name;
579 bsymnew->flags = bsymorg->flags;
580 bsymnew->section = bsymorg->section;
581 bsymnew->udata.p = (PTR) newsymP;
582 bfd_copy_private_symbol_data (bfd_asymbol_bfd (bsymorg), bsymorg,
583 bfd_asymbol_bfd (bsymnew), bsymnew);
584
585 #ifdef obj_symbol_clone_hook
586 obj_symbol_clone_hook (newsymP, orgsymP);
587 #endif
588
589 #ifdef tc_symbol_clone_hook
590 tc_symbol_clone_hook (newsymP, orgsymP);
591 #endif
592
593 if (replace)
594 {
595 if (symbol_rootP == orgsymP)
596 symbol_rootP = newsymP;
597 else if (orgsymP->sy_previous)
598 {
599 orgsymP->sy_previous->sy_next = newsymP;
600 orgsymP->sy_previous = NULL;
601 }
602 if (symbol_lastP == orgsymP)
603 symbol_lastP = newsymP;
604 else if (orgsymP->sy_next)
605 orgsymP->sy_next->sy_previous = newsymP;
606 orgsymP->sy_next = NULL;
607 debug_verify_symchain (symbol_rootP, symbol_lastP);
608
609 symbol_table_insert (newsymP);
610 }
611
612 return newsymP;
613 }
614
615 /* Referenced symbols, if they are forward references, need to be cloned
616 (without replacing the original) so that the value of the referenced
617 symbols at the point of use . */
618
619 #undef symbol_clone_if_forward_ref
620 symbolS *
621 symbol_clone_if_forward_ref (symbolS *symbolP, int is_forward)
622 {
623 if (symbolP && !LOCAL_SYMBOL_CHECK (symbolP))
624 {
625 symbolS *add_symbol = symbolP->sy_value.X_add_symbol;
626 symbolS *op_symbol = symbolP->sy_value.X_op_symbol;
627
628 if (symbolP->sy_forward_ref)
629 is_forward = 1;
630
631 if (is_forward)
632 {
633 /* assign_symbol() clones volatile symbols; pre-existing expressions
634 hold references to the original instance, but want the current
635 value. Just repeat the lookup. */
636 if (add_symbol && S_IS_VOLATILE (add_symbol))
637 add_symbol = symbol_find_exact (S_GET_NAME (add_symbol));
638 if (op_symbol && S_IS_VOLATILE (op_symbol))
639 op_symbol = symbol_find_exact (S_GET_NAME (op_symbol));
640 }
641
642 /* Re-using sy_resolving here, as this routine cannot get called from
643 symbol resolution code. */
644 if (symbolP->bsym->section == expr_section && !symbolP->sy_resolving)
645 {
646 symbolP->sy_resolving = 1;
647 add_symbol = symbol_clone_if_forward_ref (add_symbol, is_forward);
648 op_symbol = symbol_clone_if_forward_ref (op_symbol, is_forward);
649 symbolP->sy_resolving = 0;
650 }
651
652 if (symbolP->sy_forward_ref
653 || add_symbol != symbolP->sy_value.X_add_symbol
654 || op_symbol != symbolP->sy_value.X_op_symbol)
655 symbolP = symbol_clone (symbolP, 0);
656
657 symbolP->sy_value.X_add_symbol = add_symbol;
658 symbolP->sy_value.X_op_symbol = op_symbol;
659 }
660
661 return symbolP;
662 }
663
664 symbolS *
665 symbol_temp_new (segT seg, valueT ofs, fragS *frag)
666 {
667 return symbol_new (FAKE_LABEL_NAME, seg, ofs, frag);
668 }
669
670 symbolS *
671 symbol_temp_new_now (void)
672 {
673 return symbol_temp_new (now_seg, frag_now_fix (), frag_now);
674 }
675
676 symbolS *
677 symbol_temp_make (void)
678 {
679 return symbol_make (FAKE_LABEL_NAME);
680 }
681
682 /* Implement symbol table lookup.
683 In: A symbol's name as a string: '\0' can't be part of a symbol name.
684 Out: NULL if the name was not in the symbol table, else the address
685 of a struct symbol associated with that name. */
686
687 symbolS *
688 symbol_find_exact (const char *name)
689 {
690 return symbol_find_exact_noref (name, 0);
691 }
692
693 symbolS *
694 symbol_find_exact_noref (const char *name, int noref)
695 {
696 struct local_symbol *locsym;
697 symbolS* sym;
698
699 locsym = (struct local_symbol *) hash_find (local_hash, name);
700 if (locsym != NULL)
701 return (symbolS *) locsym;
702
703 sym = ((symbolS *) hash_find (sy_hash, name));
704
705 /* Any references to the symbol, except for the reference in
706 .weakref, must clear this flag, such that the symbol does not
707 turn into a weak symbol. Note that we don't have to handle the
708 local_symbol case, since a weakrefd is always promoted out of the
709 local_symbol table when it is turned into a weak symbol. */
710 if (sym && ! noref)
711 S_CLEAR_WEAKREFD (sym);
712
713 return sym;
714 }
715
716 symbolS *
717 symbol_find (const char *name)
718 {
719 return symbol_find_noref (name, 0);
720 }
721
722 symbolS *
723 symbol_find_noref (const char *name, int noref)
724 {
725 #ifdef tc_canonicalize_symbol_name
726 {
727 char *copy;
728 size_t len = strlen (name) + 1;
729
730 copy = (char *) alloca (len);
731 memcpy (copy, name, len);
732 name = tc_canonicalize_symbol_name (copy);
733 }
734 #endif
735
736 if (! symbols_case_sensitive)
737 {
738 char *copy;
739 const char *orig;
740 unsigned char c;
741
742 orig = name;
743 name = copy = (char *) alloca (strlen (name) + 1);
744
745 while ((c = *orig++) != '\0')
746 {
747 *copy++ = TOUPPER (c);
748 }
749 *copy = '\0';
750 }
751
752 return symbol_find_exact_noref (name, noref);
753 }
754
755 /* Once upon a time, symbols were kept in a singly linked list. At
756 least coff needs to be able to rearrange them from time to time, for
757 which a doubly linked list is much more convenient. Loic did these
758 as macros which seemed dangerous to me so they're now functions.
759 xoxorich. */
760
761 /* Link symbol ADDME after symbol TARGET in the chain. */
762
763 void
764 symbol_append (symbolS *addme, symbolS *target,
765 symbolS **rootPP, symbolS **lastPP)
766 {
767 if (LOCAL_SYMBOL_CHECK (addme))
768 abort ();
769 if (target != NULL && LOCAL_SYMBOL_CHECK (target))
770 abort ();
771
772 if (target == NULL)
773 {
774 know (*rootPP == NULL);
775 know (*lastPP == NULL);
776 addme->sy_next = NULL;
777 addme->sy_previous = NULL;
778 *rootPP = addme;
779 *lastPP = addme;
780 return;
781 } /* if the list is empty */
782
783 if (target->sy_next != NULL)
784 {
785 target->sy_next->sy_previous = addme;
786 }
787 else
788 {
789 know (*lastPP == target);
790 *lastPP = addme;
791 } /* if we have a next */
792
793 addme->sy_next = target->sy_next;
794 target->sy_next = addme;
795 addme->sy_previous = target;
796
797 debug_verify_symchain (symbol_rootP, symbol_lastP);
798 }
799
800 /* Set the chain pointers of SYMBOL to null. */
801
802 void
803 symbol_clear_list_pointers (symbolS *symbolP)
804 {
805 if (LOCAL_SYMBOL_CHECK (symbolP))
806 abort ();
807 symbolP->sy_next = NULL;
808 symbolP->sy_previous = NULL;
809 }
810
811 /* Remove SYMBOLP from the list. */
812
813 void
814 symbol_remove (symbolS *symbolP, symbolS **rootPP, symbolS **lastPP)
815 {
816 if (LOCAL_SYMBOL_CHECK (symbolP))
817 abort ();
818
819 if (symbolP == *rootPP)
820 {
821 *rootPP = symbolP->sy_next;
822 } /* if it was the root */
823
824 if (symbolP == *lastPP)
825 {
826 *lastPP = symbolP->sy_previous;
827 } /* if it was the tail */
828
829 if (symbolP->sy_next != NULL)
830 {
831 symbolP->sy_next->sy_previous = symbolP->sy_previous;
832 } /* if not last */
833
834 if (symbolP->sy_previous != NULL)
835 {
836 symbolP->sy_previous->sy_next = symbolP->sy_next;
837 } /* if not first */
838
839 debug_verify_symchain (*rootPP, *lastPP);
840 }
841
842 /* Link symbol ADDME before symbol TARGET in the chain. */
843
844 void
845 symbol_insert (symbolS *addme, symbolS *target,
846 symbolS **rootPP, symbolS **lastPP ATTRIBUTE_UNUSED)
847 {
848 if (LOCAL_SYMBOL_CHECK (addme))
849 abort ();
850 if (LOCAL_SYMBOL_CHECK (target))
851 abort ();
852
853 if (target->sy_previous != NULL)
854 {
855 target->sy_previous->sy_next = addme;
856 }
857 else
858 {
859 know (*rootPP == target);
860 *rootPP = addme;
861 } /* if not first */
862
863 addme->sy_previous = target->sy_previous;
864 target->sy_previous = addme;
865 addme->sy_next = target;
866
867 debug_verify_symchain (*rootPP, *lastPP);
868 }
869
870 void
871 verify_symbol_chain (symbolS *rootP, symbolS *lastP)
872 {
873 symbolS *symbolP = rootP;
874
875 if (symbolP == NULL)
876 return;
877
878 for (; symbol_next (symbolP) != NULL; symbolP = symbol_next (symbolP))
879 {
880 assert (symbolP->bsym != NULL);
881 assert (symbolP->sy_next->sy_previous == symbolP);
882 }
883
884 assert (lastP == symbolP);
885 }
886
887 static void
888 report_op_error (symbolS *symp, symbolS *left, symbolS *right)
889 {
890 char *file;
891 unsigned int line;
892 segT seg_left = S_GET_SEGMENT (left);
893 segT seg_right = right ? S_GET_SEGMENT (right) : 0;
894
895 if (expr_symbol_where (symp, &file, &line))
896 {
897 if (seg_left == undefined_section)
898 as_bad_where (file, line,
899 _("undefined symbol `%s' in operation"),
900 S_GET_NAME (left));
901 if (seg_right == undefined_section)
902 as_bad_where (file, line,
903 _("undefined symbol `%s' in operation"),
904 S_GET_NAME (right));
905 if (seg_left != undefined_section
906 && seg_right != undefined_section)
907 {
908 if (right)
909 as_bad_where (file, line,
910 _("invalid sections for operation on `%s' and `%s'"),
911 S_GET_NAME (left), S_GET_NAME (right));
912 else
913 as_bad_where (file, line,
914 _("invalid section for operation on `%s'"),
915 S_GET_NAME (left));
916 }
917
918 }
919 else
920 {
921 if (seg_left == undefined_section)
922 as_bad (_("undefined symbol `%s' in operation setting `%s'"),
923 S_GET_NAME (left), S_GET_NAME (symp));
924 if (seg_right == undefined_section)
925 as_bad (_("undefined symbol `%s' in operation setting `%s'"),
926 S_GET_NAME (right), S_GET_NAME (symp));
927 if (seg_left != undefined_section
928 && seg_right != undefined_section)
929 {
930 if (right)
931 as_bad_where (file, line,
932 _("invalid sections for operation on `%s' and `%s' setting `%s'"),
933 S_GET_NAME (left), S_GET_NAME (right), S_GET_NAME (symp));
934 else
935 as_bad_where (file, line,
936 _("invalid section for operation on `%s' setting `%s'"),
937 S_GET_NAME (left), S_GET_NAME (symp));
938 }
939 }
940 }
941
942 /* Resolve the value of a symbol. This is called during the final
943 pass over the symbol table to resolve any symbols with complex
944 values. */
945
946 valueT
947 resolve_symbol_value (symbolS *symp)
948 {
949 int resolved;
950 valueT final_val = 0;
951 segT final_seg;
952
953 if (LOCAL_SYMBOL_CHECK (symp))
954 {
955 struct local_symbol *locsym = (struct local_symbol *) symp;
956
957 final_val = locsym->lsy_value;
958 if (local_symbol_resolved_p (locsym))
959 return final_val;
960
961 final_val += local_symbol_get_frag (locsym)->fr_address / OCTETS_PER_BYTE;
962
963 if (finalize_syms)
964 {
965 locsym->lsy_value = final_val;
966 local_symbol_mark_resolved (locsym);
967 }
968
969 return final_val;
970 }
971
972 if (symp->sy_resolved)
973 {
974 if (symp->sy_value.X_op == O_constant)
975 return (valueT) symp->sy_value.X_add_number;
976 else
977 return 0;
978 }
979
980 resolved = 0;
981 final_seg = S_GET_SEGMENT (symp);
982
983 if (symp->sy_resolving)
984 {
985 if (finalize_syms)
986 as_bad (_("symbol definition loop encountered at `%s'"),
987 S_GET_NAME (symp));
988 final_val = 0;
989 resolved = 1;
990 }
991 else
992 {
993 symbolS *add_symbol, *op_symbol;
994 offsetT left, right;
995 segT seg_left, seg_right;
996 operatorT op;
997 int move_seg_ok;
998
999 symp->sy_resolving = 1;
1000
1001 /* Help out with CSE. */
1002 add_symbol = symp->sy_value.X_add_symbol;
1003 op_symbol = symp->sy_value.X_op_symbol;
1004 final_val = symp->sy_value.X_add_number;
1005 op = symp->sy_value.X_op;
1006
1007 switch (op)
1008 {
1009 default:
1010 BAD_CASE (op);
1011 break;
1012
1013 case O_absent:
1014 final_val = 0;
1015 /* Fall through. */
1016
1017 case O_constant:
1018 final_val += symp->sy_frag->fr_address / OCTETS_PER_BYTE;
1019 if (final_seg == expr_section)
1020 final_seg = absolute_section;
1021 resolved = 1;
1022 break;
1023
1024 case O_symbol:
1025 case O_symbol_rva:
1026 left = resolve_symbol_value (add_symbol);
1027 seg_left = S_GET_SEGMENT (add_symbol);
1028 if (finalize_syms)
1029 symp->sy_value.X_op_symbol = NULL;
1030
1031 do_symbol:
1032 if (S_IS_WEAKREFR (symp))
1033 {
1034 assert (final_val == 0);
1035 if (S_IS_WEAKREFR (add_symbol))
1036 {
1037 assert (add_symbol->sy_value.X_op == O_symbol
1038 && add_symbol->sy_value.X_add_number == 0);
1039 add_symbol = add_symbol->sy_value.X_add_symbol;
1040 assert (! S_IS_WEAKREFR (add_symbol));
1041 symp->sy_value.X_add_symbol = add_symbol;
1042 }
1043 }
1044
1045 if (symp->sy_mri_common)
1046 {
1047 /* This is a symbol inside an MRI common section. The
1048 relocation routines are going to handle it specially.
1049 Don't change the value. */
1050 resolved = symbol_resolved_p (add_symbol);
1051 break;
1052 }
1053
1054 if (finalize_syms && final_val == 0)
1055 {
1056 if (LOCAL_SYMBOL_CHECK (add_symbol))
1057 add_symbol = local_symbol_convert ((struct local_symbol *)
1058 add_symbol);
1059 copy_symbol_attributes (symp, add_symbol);
1060 }
1061
1062 /* If we have equated this symbol to an undefined or common
1063 symbol, keep X_op set to O_symbol, and don't change
1064 X_add_number. This permits the routine which writes out
1065 relocation to detect this case, and convert the
1066 relocation to be against the symbol to which this symbol
1067 is equated. */
1068 if (! S_IS_DEFINED (add_symbol)
1069 #if defined (OBJ_COFF) && defined (TE_PE)
1070 || S_IS_WEAK (add_symbol)
1071 #endif
1072 || S_IS_COMMON (add_symbol))
1073 {
1074 if (finalize_syms)
1075 {
1076 symp->sy_value.X_op = O_symbol;
1077 symp->sy_value.X_add_symbol = add_symbol;
1078 symp->sy_value.X_add_number = final_val;
1079 /* Use X_op_symbol as a flag. */
1080 symp->sy_value.X_op_symbol = add_symbol;
1081 final_seg = seg_left;
1082 }
1083 final_val = 0;
1084 resolved = symbol_resolved_p (add_symbol);
1085 symp->sy_resolving = 0;
1086 goto exit_dont_set_value;
1087 }
1088 else if (finalize_syms && final_seg == expr_section
1089 && seg_left != expr_section)
1090 {
1091 /* If the symbol is an expression symbol, do similarly
1092 as for undefined and common syms above. Handles
1093 "sym +/- expr" where "expr" cannot be evaluated
1094 immediately, and we want relocations to be against
1095 "sym", eg. because it is weak. */
1096 symp->sy_value.X_op = O_symbol;
1097 symp->sy_value.X_add_symbol = add_symbol;
1098 symp->sy_value.X_add_number = final_val;
1099 symp->sy_value.X_op_symbol = add_symbol;
1100 final_seg = seg_left;
1101 final_val += symp->sy_frag->fr_address + left;
1102 resolved = symbol_resolved_p (add_symbol);
1103 symp->sy_resolving = 0;
1104 goto exit_dont_set_value;
1105 }
1106 else
1107 {
1108 final_val += symp->sy_frag->fr_address + left;
1109 if (final_seg == expr_section || final_seg == undefined_section)
1110 final_seg = seg_left;
1111 }
1112
1113 resolved = symbol_resolved_p (add_symbol);
1114 if (S_IS_WEAKREFR (symp))
1115 goto exit_dont_set_value;
1116 break;
1117
1118 case O_uminus:
1119 case O_bit_not:
1120 case O_logical_not:
1121 left = resolve_symbol_value (add_symbol);
1122 seg_left = S_GET_SEGMENT (add_symbol);
1123
1124 /* By reducing these to the relevant dyadic operator, we get
1125 !S -> S == 0 permitted on anything,
1126 -S -> 0 - S only permitted on absolute
1127 ~S -> S ^ ~0 only permitted on absolute */
1128 if (op != O_logical_not && seg_left != absolute_section
1129 && finalize_syms)
1130 report_op_error (symp, add_symbol, NULL);
1131
1132 if (final_seg == expr_section || final_seg == undefined_section)
1133 final_seg = absolute_section;
1134
1135 if (op == O_uminus)
1136 left = -left;
1137 else if (op == O_logical_not)
1138 left = !left;
1139 else
1140 left = ~left;
1141
1142 final_val += left + symp->sy_frag->fr_address;
1143
1144 resolved = symbol_resolved_p (add_symbol);
1145 break;
1146
1147 case O_multiply:
1148 case O_divide:
1149 case O_modulus:
1150 case O_left_shift:
1151 case O_right_shift:
1152 case O_bit_inclusive_or:
1153 case O_bit_or_not:
1154 case O_bit_exclusive_or:
1155 case O_bit_and:
1156 case O_add:
1157 case O_subtract:
1158 case O_eq:
1159 case O_ne:
1160 case O_lt:
1161 case O_le:
1162 case O_ge:
1163 case O_gt:
1164 case O_logical_and:
1165 case O_logical_or:
1166 left = resolve_symbol_value (add_symbol);
1167 right = resolve_symbol_value (op_symbol);
1168 seg_left = S_GET_SEGMENT (add_symbol);
1169 seg_right = S_GET_SEGMENT (op_symbol);
1170
1171 /* Simplify addition or subtraction of a constant by folding the
1172 constant into X_add_number. */
1173 if (op == O_add)
1174 {
1175 if (seg_right == absolute_section)
1176 {
1177 final_val += right;
1178 goto do_symbol;
1179 }
1180 else if (seg_left == absolute_section)
1181 {
1182 final_val += left;
1183 add_symbol = op_symbol;
1184 left = right;
1185 seg_left = seg_right;
1186 goto do_symbol;
1187 }
1188 }
1189 else if (op == O_subtract)
1190 {
1191 if (seg_right == absolute_section)
1192 {
1193 final_val -= right;
1194 goto do_symbol;
1195 }
1196 }
1197
1198 move_seg_ok = 1;
1199 /* Equality and non-equality tests are permitted on anything.
1200 Subtraction, and other comparison operators are permitted if
1201 both operands are in the same section. Otherwise, both
1202 operands must be absolute. We already handled the case of
1203 addition or subtraction of a constant above. This will
1204 probably need to be changed for an object file format which
1205 supports arbitrary expressions, such as IEEE-695. */
1206 if (!(seg_left == absolute_section
1207 && seg_right == absolute_section)
1208 && !(op == O_eq || op == O_ne)
1209 && !((op == O_subtract
1210 || op == O_lt || op == O_le || op == O_ge || op == O_gt)
1211 && seg_left == seg_right
1212 && (seg_left != undefined_section
1213 || add_symbol == op_symbol)))
1214 {
1215 /* Don't emit messages unless we're finalizing the symbol value,
1216 otherwise we may get the same message multiple times. */
1217 if (finalize_syms)
1218 report_op_error (symp, add_symbol, op_symbol);
1219 /* However do not move the symbol into the absolute section
1220 if it cannot currently be resolved - this would confuse
1221 other parts of the assembler into believing that the
1222 expression had been evaluated to zero. */
1223 else
1224 move_seg_ok = 0;
1225 }
1226
1227 if (move_seg_ok
1228 && (final_seg == expr_section || final_seg == undefined_section))
1229 final_seg = absolute_section;
1230
1231 /* Check for division by zero. */
1232 if ((op == O_divide || op == O_modulus) && right == 0)
1233 {
1234 /* If seg_right is not absolute_section, then we've
1235 already issued a warning about using a bad symbol. */
1236 if (seg_right == absolute_section && finalize_syms)
1237 {
1238 char *file;
1239 unsigned int line;
1240
1241 if (expr_symbol_where (symp, &file, &line))
1242 as_bad_where (file, line, _("division by zero"));
1243 else
1244 as_bad (_("division by zero when setting `%s'"),
1245 S_GET_NAME (symp));
1246 }
1247
1248 right = 1;
1249 }
1250
1251 switch (symp->sy_value.X_op)
1252 {
1253 case O_multiply: left *= right; break;
1254 case O_divide: left /= right; break;
1255 case O_modulus: left %= right; break;
1256 case O_left_shift: left <<= right; break;
1257 case O_right_shift: left >>= right; break;
1258 case O_bit_inclusive_or: left |= right; break;
1259 case O_bit_or_not: left |= ~right; break;
1260 case O_bit_exclusive_or: left ^= right; break;
1261 case O_bit_and: left &= right; break;
1262 case O_add: left += right; break;
1263 case O_subtract: left -= right; break;
1264 case O_eq:
1265 case O_ne:
1266 left = (left == right && seg_left == seg_right
1267 && (seg_left != undefined_section
1268 || add_symbol == op_symbol)
1269 ? ~ (offsetT) 0 : 0);
1270 if (symp->sy_value.X_op == O_ne)
1271 left = ~left;
1272 break;
1273 case O_lt: left = left < right ? ~ (offsetT) 0 : 0; break;
1274 case O_le: left = left <= right ? ~ (offsetT) 0 : 0; break;
1275 case O_ge: left = left >= right ? ~ (offsetT) 0 : 0; break;
1276 case O_gt: left = left > right ? ~ (offsetT) 0 : 0; break;
1277 case O_logical_and: left = left && right; break;
1278 case O_logical_or: left = left || right; break;
1279 default: abort ();
1280 }
1281
1282 final_val += symp->sy_frag->fr_address + left;
1283 if (final_seg == expr_section || final_seg == undefined_section)
1284 {
1285 if (seg_left == undefined_section
1286 || seg_right == undefined_section)
1287 final_seg = undefined_section;
1288 else if (seg_left == absolute_section)
1289 final_seg = seg_right;
1290 else
1291 final_seg = seg_left;
1292 }
1293 resolved = (symbol_resolved_p (add_symbol)
1294 && symbol_resolved_p (op_symbol));
1295 break;
1296
1297 case O_register:
1298 case O_big:
1299 case O_illegal:
1300 /* Give an error (below) if not in expr_section. We don't
1301 want to worry about expr_section symbols, because they
1302 are fictional (they are created as part of expression
1303 resolution), and any problems may not actually mean
1304 anything. */
1305 break;
1306 }
1307
1308 symp->sy_resolving = 0;
1309 }
1310
1311 if (finalize_syms)
1312 S_SET_VALUE (symp, final_val);
1313
1314 exit_dont_set_value:
1315 /* Always set the segment, even if not finalizing the value.
1316 The segment is used to determine whether a symbol is defined. */
1317 S_SET_SEGMENT (symp, final_seg);
1318
1319 /* Don't worry if we can't resolve an expr_section symbol. */
1320 if (finalize_syms)
1321 {
1322 if (resolved)
1323 symp->sy_resolved = 1;
1324 else if (S_GET_SEGMENT (symp) != expr_section)
1325 {
1326 as_bad (_("can't resolve value for symbol `%s'"),
1327 S_GET_NAME (symp));
1328 symp->sy_resolved = 1;
1329 }
1330 }
1331
1332 return final_val;
1333 }
1334
1335 static void resolve_local_symbol (const char *, PTR);
1336
1337 /* A static function passed to hash_traverse. */
1338
1339 static void
1340 resolve_local_symbol (const char *key ATTRIBUTE_UNUSED, PTR value)
1341 {
1342 if (value != NULL)
1343 resolve_symbol_value (value);
1344 }
1345
1346 /* Resolve all local symbols. */
1347
1348 void
1349 resolve_local_symbol_values (void)
1350 {
1351 hash_traverse (local_hash, resolve_local_symbol);
1352 }
1353
1354 /* Obtain the current value of a symbol without changing any
1355 sub-expressions used. */
1356
1357 int
1358 snapshot_symbol (symbolS **symbolPP, valueT *valueP, segT *segP, fragS **fragPP)
1359 {
1360 symbolS *symbolP = *symbolPP;
1361
1362 if (LOCAL_SYMBOL_CHECK (symbolP))
1363 {
1364 struct local_symbol *locsym = (struct local_symbol *) symbolP;
1365
1366 *valueP = locsym->lsy_value;
1367 *segP = locsym->lsy_section;
1368 *fragPP = local_symbol_get_frag (locsym);
1369 }
1370 else
1371 {
1372 expressionS expr = symbolP->sy_value;
1373
1374 if (!symbolP->sy_resolved && expr.X_op != O_illegal)
1375 {
1376 int resolved;
1377
1378 if (symbolP->sy_resolving)
1379 return 0;
1380 symbolP->sy_resolving = 1;
1381 resolved = resolve_expression (&expr);
1382 symbolP->sy_resolving = 0;
1383 if (!resolved)
1384 return 0;
1385
1386 switch (expr.X_op)
1387 {
1388 case O_constant:
1389 case O_register:
1390 if (!symbol_equated_p (symbolP))
1391 break;
1392 /* Fall thru. */
1393 case O_symbol:
1394 case O_symbol_rva:
1395 symbolP = expr.X_add_symbol;
1396 break;
1397 default:
1398 return 0;
1399 }
1400 }
1401
1402 /* Never change a defined symbol. */
1403 if (symbolP->bsym->section == undefined_section
1404 || symbolP->bsym->section == expr_section)
1405 *symbolPP = symbolP;
1406 *valueP = expr.X_add_number;
1407 *segP = symbolP->bsym->section;
1408 *fragPP = symbolP->sy_frag;
1409
1410 if (*segP == expr_section)
1411 switch (expr.X_op)
1412 {
1413 case O_constant: *segP = absolute_section; break;
1414 case O_register: *segP = reg_section; break;
1415 default: break;
1416 }
1417 }
1418
1419 return 1;
1420 }
1421
1422 /* Dollar labels look like a number followed by a dollar sign. Eg, "42$".
1423 They are *really* local. That is, they go out of scope whenever we see a
1424 label that isn't local. Also, like fb labels, there can be multiple
1425 instances of a dollar label. Therefor, we name encode each instance with
1426 the instance number, keep a list of defined symbols separate from the real
1427 symbol table, and we treat these buggers as a sparse array. */
1428
1429 static long *dollar_labels;
1430 static long *dollar_label_instances;
1431 static char *dollar_label_defines;
1432 static unsigned long dollar_label_count;
1433 static unsigned long dollar_label_max;
1434
1435 int
1436 dollar_label_defined (long label)
1437 {
1438 long *i;
1439
1440 know ((dollar_labels != NULL) || (dollar_label_count == 0));
1441
1442 for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
1443 if (*i == label)
1444 return dollar_label_defines[i - dollar_labels];
1445
1446 /* If we get here, label isn't defined. */
1447 return 0;
1448 }
1449
1450 static long
1451 dollar_label_instance (long label)
1452 {
1453 long *i;
1454
1455 know ((dollar_labels != NULL) || (dollar_label_count == 0));
1456
1457 for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
1458 if (*i == label)
1459 return (dollar_label_instances[i - dollar_labels]);
1460
1461 /* If we get here, we haven't seen the label before.
1462 Therefore its instance count is zero. */
1463 return 0;
1464 }
1465
1466 void
1467 dollar_label_clear (void)
1468 {
1469 memset (dollar_label_defines, '\0', (unsigned int) dollar_label_count);
1470 }
1471
1472 #define DOLLAR_LABEL_BUMP_BY 10
1473
1474 void
1475 define_dollar_label (long label)
1476 {
1477 long *i;
1478
1479 for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i)
1480 if (*i == label)
1481 {
1482 ++dollar_label_instances[i - dollar_labels];
1483 dollar_label_defines[i - dollar_labels] = 1;
1484 return;
1485 }
1486
1487 /* If we get to here, we don't have label listed yet. */
1488
1489 if (dollar_labels == NULL)
1490 {
1491 dollar_labels = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long));
1492 dollar_label_instances = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long));
1493 dollar_label_defines = xmalloc (DOLLAR_LABEL_BUMP_BY);
1494 dollar_label_max = DOLLAR_LABEL_BUMP_BY;
1495 dollar_label_count = 0;
1496 }
1497 else if (dollar_label_count == dollar_label_max)
1498 {
1499 dollar_label_max += DOLLAR_LABEL_BUMP_BY;
1500 dollar_labels = (long *) xrealloc ((char *) dollar_labels,
1501 dollar_label_max * sizeof (long));
1502 dollar_label_instances = (long *) xrealloc ((char *) dollar_label_instances,
1503 dollar_label_max * sizeof (long));
1504 dollar_label_defines = xrealloc (dollar_label_defines, dollar_label_max);
1505 } /* if we needed to grow */
1506
1507 dollar_labels[dollar_label_count] = label;
1508 dollar_label_instances[dollar_label_count] = 1;
1509 dollar_label_defines[dollar_label_count] = 1;
1510 ++dollar_label_count;
1511 }
1512
1513 /* Caller must copy returned name: we re-use the area for the next name.
1514
1515 The mth occurence of label n: is turned into the symbol "Ln^Am"
1516 where n is the label number and m is the instance number. "L" makes
1517 it a label discarded unless debugging and "^A"('\1') ensures no
1518 ordinary symbol SHOULD get the same name as a local label
1519 symbol. The first "4:" is "L4^A1" - the m numbers begin at 1.
1520
1521 fb labels get the same treatment, except that ^B is used in place
1522 of ^A. */
1523
1524 char * /* Return local label name. */
1525 dollar_label_name (register long n, /* we just saw "n$:" : n a number. */
1526 register int augend /* 0 for current instance, 1 for new instance. */)
1527 {
1528 long i;
1529 /* Returned to caller, then copied. Used for created names ("4f"). */
1530 static char symbol_name_build[24];
1531 register char *p;
1532 register char *q;
1533 char symbol_name_temporary[20]; /* Build up a number, BACKWARDS. */
1534
1535 know (n >= 0);
1536 know (augend == 0 || augend == 1);
1537 p = symbol_name_build;
1538 #ifdef LOCAL_LABEL_PREFIX
1539 *p++ = LOCAL_LABEL_PREFIX;
1540 #endif
1541 *p++ = 'L';
1542
1543 /* Next code just does sprintf( {}, "%d", n); */
1544 /* Label number. */
1545 q = symbol_name_temporary;
1546 for (*q++ = 0, i = n; i; ++q)
1547 {
1548 *q = i % 10 + '0';
1549 i /= 10;
1550 }
1551 while ((*p = *--q) != '\0')
1552 ++p;
1553
1554 *p++ = DOLLAR_LABEL_CHAR; /* ^A */
1555
1556 /* Instance number. */
1557 q = symbol_name_temporary;
1558 for (*q++ = 0, i = dollar_label_instance (n) + augend; i; ++q)
1559 {
1560 *q = i % 10 + '0';
1561 i /= 10;
1562 }
1563 while ((*p++ = *--q) != '\0');;
1564
1565 /* The label, as a '\0' ended string, starts at symbol_name_build. */
1566 return symbol_name_build;
1567 }
1568
1569 /* Somebody else's idea of local labels. They are made by "n:" where n
1570 is any decimal digit. Refer to them with
1571 "nb" for previous (backward) n:
1572 or "nf" for next (forward) n:.
1573
1574 We do a little better and let n be any number, not just a single digit, but
1575 since the other guy's assembler only does ten, we treat the first ten
1576 specially.
1577
1578 Like someone else's assembler, we have one set of local label counters for
1579 entire assembly, not one set per (sub)segment like in most assemblers. This
1580 implies that one can refer to a label in another segment, and indeed some
1581 crufty compilers have done just that.
1582
1583 Since there could be a LOT of these things, treat them as a sparse
1584 array. */
1585
1586 #define FB_LABEL_SPECIAL (10)
1587
1588 static long fb_low_counter[FB_LABEL_SPECIAL];
1589 static long *fb_labels;
1590 static long *fb_label_instances;
1591 static long fb_label_count;
1592 static long fb_label_max;
1593
1594 /* This must be more than FB_LABEL_SPECIAL. */
1595 #define FB_LABEL_BUMP_BY (FB_LABEL_SPECIAL + 6)
1596
1597 static void
1598 fb_label_init (void)
1599 {
1600 memset ((void *) fb_low_counter, '\0', sizeof (fb_low_counter));
1601 }
1602
1603 /* Add one to the instance number of this fb label. */
1604
1605 void
1606 fb_label_instance_inc (long label)
1607 {
1608 long *i;
1609
1610 if (label < FB_LABEL_SPECIAL)
1611 {
1612 ++fb_low_counter[label];
1613 return;
1614 }
1615
1616 if (fb_labels != NULL)
1617 {
1618 for (i = fb_labels + FB_LABEL_SPECIAL;
1619 i < fb_labels + fb_label_count; ++i)
1620 {
1621 if (*i == label)
1622 {
1623 ++fb_label_instances[i - fb_labels];
1624 return;
1625 } /* if we find it */
1626 } /* for each existing label */
1627 }
1628
1629 /* If we get to here, we don't have label listed yet. */
1630
1631 if (fb_labels == NULL)
1632 {
1633 fb_labels = (long *) xmalloc (FB_LABEL_BUMP_BY * sizeof (long));
1634 fb_label_instances = (long *) xmalloc (FB_LABEL_BUMP_BY * sizeof (long));
1635 fb_label_max = FB_LABEL_BUMP_BY;
1636 fb_label_count = FB_LABEL_SPECIAL;
1637
1638 }
1639 else if (fb_label_count == fb_label_max)
1640 {
1641 fb_label_max += FB_LABEL_BUMP_BY;
1642 fb_labels = (long *) xrealloc ((char *) fb_labels,
1643 fb_label_max * sizeof (long));
1644 fb_label_instances = (long *) xrealloc ((char *) fb_label_instances,
1645 fb_label_max * sizeof (long));
1646 } /* if we needed to grow */
1647
1648 fb_labels[fb_label_count] = label;
1649 fb_label_instances[fb_label_count] = 1;
1650 ++fb_label_count;
1651 }
1652
1653 static long
1654 fb_label_instance (long label)
1655 {
1656 long *i;
1657
1658 if (label < FB_LABEL_SPECIAL)
1659 {
1660 return (fb_low_counter[label]);
1661 }
1662
1663 if (fb_labels != NULL)
1664 {
1665 for (i = fb_labels + FB_LABEL_SPECIAL;
1666 i < fb_labels + fb_label_count; ++i)
1667 {
1668 if (*i == label)
1669 {
1670 return (fb_label_instances[i - fb_labels]);
1671 } /* if we find it */
1672 } /* for each existing label */
1673 }
1674
1675 /* We didn't find the label, so this must be a reference to the
1676 first instance. */
1677 return 0;
1678 }
1679
1680 /* Caller must copy returned name: we re-use the area for the next name.
1681
1682 The mth occurence of label n: is turned into the symbol "Ln^Bm"
1683 where n is the label number and m is the instance number. "L" makes
1684 it a label discarded unless debugging and "^B"('\2') ensures no
1685 ordinary symbol SHOULD get the same name as a local label
1686 symbol. The first "4:" is "L4^B1" - the m numbers begin at 1.
1687
1688 dollar labels get the same treatment, except that ^A is used in
1689 place of ^B. */
1690
1691 char * /* Return local label name. */
1692 fb_label_name (long n, /* We just saw "n:", "nf" or "nb" : n a number. */
1693 long augend /* 0 for nb, 1 for n:, nf. */)
1694 {
1695 long i;
1696 /* Returned to caller, then copied. Used for created names ("4f"). */
1697 static char symbol_name_build[24];
1698 register char *p;
1699 register char *q;
1700 char symbol_name_temporary[20]; /* Build up a number, BACKWARDS. */
1701
1702 know (n >= 0);
1703 #ifdef TC_MMIX
1704 know ((unsigned long) augend <= 2 /* See mmix_fb_label. */);
1705 #else
1706 know ((unsigned long) augend <= 1);
1707 #endif
1708 p = symbol_name_build;
1709 #ifdef LOCAL_LABEL_PREFIX
1710 *p++ = LOCAL_LABEL_PREFIX;
1711 #endif
1712 *p++ = 'L';
1713
1714 /* Next code just does sprintf( {}, "%d", n); */
1715 /* Label number. */
1716 q = symbol_name_temporary;
1717 for (*q++ = 0, i = n; i; ++q)
1718 {
1719 *q = i % 10 + '0';
1720 i /= 10;
1721 }
1722 while ((*p = *--q) != '\0')
1723 ++p;
1724
1725 *p++ = LOCAL_LABEL_CHAR; /* ^B */
1726
1727 /* Instance number. */
1728 q = symbol_name_temporary;
1729 for (*q++ = 0, i = fb_label_instance (n) + augend; i; ++q)
1730 {
1731 *q = i % 10 + '0';
1732 i /= 10;
1733 }
1734 while ((*p++ = *--q) != '\0');;
1735
1736 /* The label, as a '\0' ended string, starts at symbol_name_build. */
1737 return (symbol_name_build);
1738 }
1739
1740 /* Decode name that may have been generated by foo_label_name() above.
1741 If the name wasn't generated by foo_label_name(), then return it
1742 unaltered. This is used for error messages. */
1743
1744 char *
1745 decode_local_label_name (char *s)
1746 {
1747 char *p;
1748 char *symbol_decode;
1749 int label_number;
1750 int instance_number;
1751 char *type;
1752 const char *message_format;
1753 int index = 0;
1754
1755 #ifdef LOCAL_LABEL_PREFIX
1756 if (s[index] == LOCAL_LABEL_PREFIX)
1757 ++index;
1758 #endif
1759
1760 if (s[index] != 'L')
1761 return s;
1762
1763 for (label_number = 0, p = s + index + 1; ISDIGIT (*p); ++p)
1764 label_number = (10 * label_number) + *p - '0';
1765
1766 if (*p == DOLLAR_LABEL_CHAR)
1767 type = "dollar";
1768 else if (*p == LOCAL_LABEL_CHAR)
1769 type = "fb";
1770 else
1771 return s;
1772
1773 for (instance_number = 0, p++; ISDIGIT (*p); ++p)
1774 instance_number = (10 * instance_number) + *p - '0';
1775
1776 message_format = _("\"%d\" (instance number %d of a %s label)");
1777 symbol_decode = obstack_alloc (&notes, strlen (message_format) + 30);
1778 sprintf (symbol_decode, message_format, label_number, instance_number, type);
1779
1780 return symbol_decode;
1781 }
1782
1783 /* Get the value of a symbol. */
1784
1785 valueT
1786 S_GET_VALUE (symbolS *s)
1787 {
1788 if (LOCAL_SYMBOL_CHECK (s))
1789 return resolve_symbol_value (s);
1790
1791 if (!s->sy_resolved)
1792 {
1793 valueT val = resolve_symbol_value (s);
1794 if (!finalize_syms)
1795 return val;
1796 }
1797 if (S_IS_WEAKREFR (s))
1798 return S_GET_VALUE (s->sy_value.X_add_symbol);
1799
1800 if (s->sy_value.X_op != O_constant)
1801 {
1802 if (! s->sy_resolved
1803 || s->sy_value.X_op != O_symbol
1804 || (S_IS_DEFINED (s) && ! S_IS_COMMON (s)))
1805 as_bad (_("attempt to get value of unresolved symbol `%s'"),
1806 S_GET_NAME (s));
1807 }
1808 return (valueT) s->sy_value.X_add_number;
1809 }
1810
1811 /* Set the value of a symbol. */
1812
1813 void
1814 S_SET_VALUE (symbolS *s, valueT val)
1815 {
1816 if (LOCAL_SYMBOL_CHECK (s))
1817 {
1818 ((struct local_symbol *) s)->lsy_value = val;
1819 return;
1820 }
1821
1822 s->sy_value.X_op = O_constant;
1823 s->sy_value.X_add_number = (offsetT) val;
1824 s->sy_value.X_unsigned = 0;
1825 S_CLEAR_WEAKREFR (s);
1826 }
1827
1828 void
1829 copy_symbol_attributes (symbolS *dest, symbolS *src)
1830 {
1831 if (LOCAL_SYMBOL_CHECK (dest))
1832 dest = local_symbol_convert ((struct local_symbol *) dest);
1833 if (LOCAL_SYMBOL_CHECK (src))
1834 src = local_symbol_convert ((struct local_symbol *) src);
1835
1836 /* In an expression, transfer the settings of these flags.
1837 The user can override later, of course. */
1838 #define COPIED_SYMFLAGS (BSF_FUNCTION | BSF_OBJECT)
1839 dest->bsym->flags |= src->bsym->flags & COPIED_SYMFLAGS;
1840
1841 #ifdef OBJ_COPY_SYMBOL_ATTRIBUTES
1842 OBJ_COPY_SYMBOL_ATTRIBUTES (dest, src);
1843 #endif
1844 }
1845
1846 int
1847 S_IS_FUNCTION (symbolS *s)
1848 {
1849 flagword flags;
1850
1851 if (LOCAL_SYMBOL_CHECK (s))
1852 return 0;
1853
1854 flags = s->bsym->flags;
1855
1856 return (flags & BSF_FUNCTION) != 0;
1857 }
1858
1859 int
1860 S_IS_EXTERNAL (symbolS *s)
1861 {
1862 flagword flags;
1863
1864 if (LOCAL_SYMBOL_CHECK (s))
1865 return 0;
1866
1867 flags = s->bsym->flags;
1868
1869 /* Sanity check. */
1870 if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL))
1871 abort ();
1872
1873 return (flags & BSF_GLOBAL) != 0;
1874 }
1875
1876 int
1877 S_IS_WEAK (symbolS *s)
1878 {
1879 if (LOCAL_SYMBOL_CHECK (s))
1880 return 0;
1881 /* Conceptually, a weakrefr is weak if the referenced symbol is. We
1882 could probably handle a WEAKREFR as always weak though. E.g., if
1883 the referenced symbol has lost its weak status, there's no reason
1884 to keep handling the weakrefr as if it was weak. */
1885 if (S_IS_WEAKREFR (s))
1886 return S_IS_WEAK (s->sy_value.X_add_symbol);
1887 return (s->bsym->flags & BSF_WEAK) != 0;
1888 }
1889
1890 int
1891 S_IS_WEAKREFR (symbolS *s)
1892 {
1893 if (LOCAL_SYMBOL_CHECK (s))
1894 return 0;
1895 return s->sy_weakrefr != 0;
1896 }
1897
1898 int
1899 S_IS_WEAKREFD (symbolS *s)
1900 {
1901 if (LOCAL_SYMBOL_CHECK (s))
1902 return 0;
1903 return s->sy_weakrefd != 0;
1904 }
1905
1906 int
1907 S_IS_COMMON (symbolS *s)
1908 {
1909 if (LOCAL_SYMBOL_CHECK (s))
1910 return 0;
1911 return bfd_is_com_section (s->bsym->section);
1912 }
1913
1914 int
1915 S_IS_DEFINED (symbolS *s)
1916 {
1917 if (LOCAL_SYMBOL_CHECK (s))
1918 return ((struct local_symbol *) s)->lsy_section != undefined_section;
1919 return s->bsym->section != undefined_section;
1920 }
1921
1922
1923 #ifndef EXTERN_FORCE_RELOC
1924 #define EXTERN_FORCE_RELOC IS_ELF
1925 #endif
1926
1927 /* Return true for symbols that should not be reduced to section
1928 symbols or eliminated from expressions, because they may be
1929 overridden by the linker. */
1930 int
1931 S_FORCE_RELOC (symbolS *s, int strict)
1932 {
1933 if (LOCAL_SYMBOL_CHECK (s))
1934 return ((struct local_symbol *) s)->lsy_section == undefined_section;
1935
1936 return ((strict
1937 && ((s->bsym->flags & BSF_WEAK) != 0
1938 || (EXTERN_FORCE_RELOC
1939 && (s->bsym->flags & BSF_GLOBAL) != 0)))
1940 || s->bsym->section == undefined_section
1941 || bfd_is_com_section (s->bsym->section));
1942 }
1943
1944 int
1945 S_IS_DEBUG (symbolS *s)
1946 {
1947 if (LOCAL_SYMBOL_CHECK (s))
1948 return 0;
1949 if (s->bsym->flags & BSF_DEBUGGING)
1950 return 1;
1951 return 0;
1952 }
1953
1954 int
1955 S_IS_LOCAL (symbolS *s)
1956 {
1957 flagword flags;
1958 const char *name;
1959
1960 if (LOCAL_SYMBOL_CHECK (s))
1961 return 1;
1962
1963 flags = s->bsym->flags;
1964
1965 /* Sanity check. */
1966 if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL))
1967 abort ();
1968
1969 if (bfd_get_section (s->bsym) == reg_section)
1970 return 1;
1971
1972 if (flag_strip_local_absolute
1973 /* Keep BSF_FILE symbols in order to allow debuggers to identify
1974 the source file even when the object file is stripped. */
1975 && (flags & (BSF_GLOBAL | BSF_FILE)) == 0
1976 && bfd_get_section (s->bsym) == absolute_section)
1977 return 1;
1978
1979 name = S_GET_NAME (s);
1980 return (name != NULL
1981 && ! S_IS_DEBUG (s)
1982 && (strchr (name, DOLLAR_LABEL_CHAR)
1983 || strchr (name, LOCAL_LABEL_CHAR)
1984 || (! flag_keep_locals
1985 && (bfd_is_local_label (stdoutput, s->bsym)
1986 || (flag_mri
1987 && name[0] == '?'
1988 && name[1] == '?')))));
1989 }
1990
1991 int
1992 S_IS_STABD (symbolS *s)
1993 {
1994 return S_GET_NAME (s) == 0;
1995 }
1996
1997 int
1998 S_IS_VOLATILE (const symbolS *s)
1999 {
2000 if (LOCAL_SYMBOL_CHECK (s))
2001 return 0;
2002 return s->sy_volatile;
2003 }
2004
2005 int
2006 S_IS_FORWARD_REF (const symbolS *s)
2007 {
2008 if (LOCAL_SYMBOL_CHECK (s))
2009 return 0;
2010 return s->sy_forward_ref;
2011 }
2012
2013 const char *
2014 S_GET_NAME (symbolS *s)
2015 {
2016 if (LOCAL_SYMBOL_CHECK (s))
2017 return ((struct local_symbol *) s)->lsy_name;
2018 return s->bsym->name;
2019 }
2020
2021 segT
2022 S_GET_SEGMENT (symbolS *s)
2023 {
2024 if (LOCAL_SYMBOL_CHECK (s))
2025 return ((struct local_symbol *) s)->lsy_section;
2026 return s->bsym->section;
2027 }
2028
2029 void
2030 S_SET_SEGMENT (symbolS *s, segT seg)
2031 {
2032 /* Don't reassign section symbols. The direct reason is to prevent seg
2033 faults assigning back to const global symbols such as *ABS*, but it
2034 shouldn't happen anyway. */
2035
2036 if (LOCAL_SYMBOL_CHECK (s))
2037 {
2038 if (seg == reg_section)
2039 s = local_symbol_convert ((struct local_symbol *) s);
2040 else
2041 {
2042 ((struct local_symbol *) s)->lsy_section = seg;
2043 return;
2044 }
2045 }
2046
2047 if (s->bsym->flags & BSF_SECTION_SYM)
2048 {
2049 if (s->bsym->section != seg)
2050 abort ();
2051 }
2052 else
2053 s->bsym->section = seg;
2054 }
2055
2056 void
2057 S_SET_EXTERNAL (symbolS *s)
2058 {
2059 if (LOCAL_SYMBOL_CHECK (s))
2060 s = local_symbol_convert ((struct local_symbol *) s);
2061 if ((s->bsym->flags & BSF_WEAK) != 0)
2062 {
2063 /* Let .weak override .global. */
2064 return;
2065 }
2066 if (s->bsym->flags & BSF_SECTION_SYM)
2067 {
2068 char * file;
2069 unsigned int line;
2070
2071 /* Do not reassign section symbols. */
2072 as_where (& file, & line);
2073 as_warn_where (file, line,
2074 _("section symbols are already global"));
2075 return;
2076 }
2077 s->bsym->flags |= BSF_GLOBAL;
2078 s->bsym->flags &= ~(BSF_LOCAL | BSF_WEAK);
2079
2080 #ifdef USE_UNIQUE
2081 if (! an_external_name && S_GET_NAME(s)[0] != '.')
2082 an_external_name = S_GET_NAME (s);
2083 #endif
2084 }
2085
2086 void
2087 S_CLEAR_EXTERNAL (symbolS *s)
2088 {
2089 if (LOCAL_SYMBOL_CHECK (s))
2090 return;
2091 if ((s->bsym->flags & BSF_WEAK) != 0)
2092 {
2093 /* Let .weak override. */
2094 return;
2095 }
2096 s->bsym->flags |= BSF_LOCAL;
2097 s->bsym->flags &= ~(BSF_GLOBAL | BSF_WEAK);
2098 }
2099
2100 void
2101 S_SET_WEAK (symbolS *s)
2102 {
2103 if (LOCAL_SYMBOL_CHECK (s))
2104 s = local_symbol_convert ((struct local_symbol *) s);
2105 #ifdef obj_set_weak_hook
2106 obj_set_weak_hook (s);
2107 #endif
2108 s->bsym->flags |= BSF_WEAK;
2109 s->bsym->flags &= ~(BSF_GLOBAL | BSF_LOCAL);
2110 }
2111
2112 void
2113 S_SET_WEAKREFR (symbolS *s)
2114 {
2115 if (LOCAL_SYMBOL_CHECK (s))
2116 s = local_symbol_convert ((struct local_symbol *) s);
2117 s->sy_weakrefr = 1;
2118 /* If the alias was already used, make sure we mark the target as
2119 used as well, otherwise it might be dropped from the symbol
2120 table. This may have unintended side effects if the alias is
2121 later redirected to another symbol, such as keeping the unused
2122 previous target in the symbol table. Since it will be weak, it's
2123 not a big deal. */
2124 if (s->sy_used)
2125 symbol_mark_used (s->sy_value.X_add_symbol);
2126 }
2127
2128 void
2129 S_CLEAR_WEAKREFR (symbolS *s)
2130 {
2131 if (LOCAL_SYMBOL_CHECK (s))
2132 return;
2133 s->sy_weakrefr = 0;
2134 }
2135
2136 void
2137 S_SET_WEAKREFD (symbolS *s)
2138 {
2139 if (LOCAL_SYMBOL_CHECK (s))
2140 s = local_symbol_convert ((struct local_symbol *) s);
2141 s->sy_weakrefd = 1;
2142 S_SET_WEAK (s);
2143 }
2144
2145 void
2146 S_CLEAR_WEAKREFD (symbolS *s)
2147 {
2148 if (LOCAL_SYMBOL_CHECK (s))
2149 return;
2150 if (s->sy_weakrefd)
2151 {
2152 s->sy_weakrefd = 0;
2153 /* If a weakref target symbol is weak, then it was never
2154 referenced directly before, not even in a .global directive,
2155 so decay it to local. If it remains undefined, it will be
2156 later turned into a global, like any other undefined
2157 symbol. */
2158 if (s->bsym->flags & BSF_WEAK)
2159 {
2160 #ifdef obj_clear_weak_hook
2161 obj_clear_weak_hook (s);
2162 #endif
2163 s->bsym->flags &= ~BSF_WEAK;
2164 s->bsym->flags |= BSF_LOCAL;
2165 }
2166 }
2167 }
2168
2169 void
2170 S_SET_THREAD_LOCAL (symbolS *s)
2171 {
2172 if (LOCAL_SYMBOL_CHECK (s))
2173 s = local_symbol_convert ((struct local_symbol *) s);
2174 if (bfd_is_com_section (s->bsym->section)
2175 && (s->bsym->flags & BSF_THREAD_LOCAL) != 0)
2176 return;
2177 s->bsym->flags |= BSF_THREAD_LOCAL;
2178 if ((s->bsym->flags & BSF_FUNCTION) != 0)
2179 as_bad (_("Accessing function `%s' as thread-local object"),
2180 S_GET_NAME (s));
2181 else if (! bfd_is_und_section (s->bsym->section)
2182 && (s->bsym->section->flags & SEC_THREAD_LOCAL) == 0)
2183 as_bad (_("Accessing `%s' as thread-local object"),
2184 S_GET_NAME (s));
2185 }
2186
2187 void
2188 S_SET_NAME (symbolS *s, const char *name)
2189 {
2190 if (LOCAL_SYMBOL_CHECK (s))
2191 {
2192 ((struct local_symbol *) s)->lsy_name = name;
2193 return;
2194 }
2195 s->bsym->name = name;
2196 }
2197
2198 void
2199 S_SET_VOLATILE (symbolS *s)
2200 {
2201 if (LOCAL_SYMBOL_CHECK (s))
2202 s = local_symbol_convert ((struct local_symbol *) s);
2203 s->sy_volatile = 1;
2204 }
2205
2206 void
2207 S_CLEAR_VOLATILE (symbolS *s)
2208 {
2209 if (!LOCAL_SYMBOL_CHECK (s))
2210 s->sy_volatile = 0;
2211 }
2212
2213 void
2214 S_SET_FORWARD_REF (symbolS *s)
2215 {
2216 if (LOCAL_SYMBOL_CHECK (s))
2217 s = local_symbol_convert ((struct local_symbol *) s);
2218 s->sy_forward_ref = 1;
2219 }
2220
2221 /* Return the previous symbol in a chain. */
2222
2223 symbolS *
2224 symbol_previous (symbolS *s)
2225 {
2226 if (LOCAL_SYMBOL_CHECK (s))
2227 abort ();
2228 return s->sy_previous;
2229 }
2230
2231 /* Return the next symbol in a chain. */
2232
2233 symbolS *
2234 symbol_next (symbolS *s)
2235 {
2236 if (LOCAL_SYMBOL_CHECK (s))
2237 abort ();
2238 return s->sy_next;
2239 }
2240
2241 /* Return a pointer to the value of a symbol as an expression. */
2242
2243 expressionS *
2244 symbol_get_value_expression (symbolS *s)
2245 {
2246 if (LOCAL_SYMBOL_CHECK (s))
2247 s = local_symbol_convert ((struct local_symbol *) s);
2248 return &s->sy_value;
2249 }
2250
2251 /* Set the value of a symbol to an expression. */
2252
2253 void
2254 symbol_set_value_expression (symbolS *s, const expressionS *exp)
2255 {
2256 if (LOCAL_SYMBOL_CHECK (s))
2257 s = local_symbol_convert ((struct local_symbol *) s);
2258 s->sy_value = *exp;
2259 S_CLEAR_WEAKREFR (s);
2260 }
2261
2262 /* Return a pointer to the X_add_number component of a symbol. */
2263
2264 offsetT *
2265 symbol_X_add_number (symbolS *s)
2266 {
2267 if (LOCAL_SYMBOL_CHECK (s))
2268 return (offsetT *) &((struct local_symbol *) s)->lsy_value;
2269
2270 return &s->sy_value.X_add_number;
2271 }
2272
2273 /* Set the value of SYM to the current position in the current segment. */
2274
2275 void
2276 symbol_set_value_now (symbolS *sym)
2277 {
2278 S_SET_SEGMENT (sym, now_seg);
2279 S_SET_VALUE (sym, frag_now_fix ());
2280 symbol_set_frag (sym, frag_now);
2281 }
2282
2283 /* Set the frag of a symbol. */
2284
2285 void
2286 symbol_set_frag (symbolS *s, fragS *f)
2287 {
2288 if (LOCAL_SYMBOL_CHECK (s))
2289 {
2290 local_symbol_set_frag ((struct local_symbol *) s, f);
2291 return;
2292 }
2293 s->sy_frag = f;
2294 S_CLEAR_WEAKREFR (s);
2295 }
2296
2297 /* Return the frag of a symbol. */
2298
2299 fragS *
2300 symbol_get_frag (symbolS *s)
2301 {
2302 if (LOCAL_SYMBOL_CHECK (s))
2303 return local_symbol_get_frag ((struct local_symbol *) s);
2304 return s->sy_frag;
2305 }
2306
2307 /* Mark a symbol as having been used. */
2308
2309 void
2310 symbol_mark_used (symbolS *s)
2311 {
2312 if (LOCAL_SYMBOL_CHECK (s))
2313 return;
2314 s->sy_used = 1;
2315 if (S_IS_WEAKREFR (s))
2316 symbol_mark_used (s->sy_value.X_add_symbol);
2317 }
2318
2319 /* Clear the mark of whether a symbol has been used. */
2320
2321 void
2322 symbol_clear_used (symbolS *s)
2323 {
2324 if (LOCAL_SYMBOL_CHECK (s))
2325 s = local_symbol_convert ((struct local_symbol *) s);
2326 s->sy_used = 0;
2327 }
2328
2329 /* Return whether a symbol has been used. */
2330
2331 int
2332 symbol_used_p (symbolS *s)
2333 {
2334 if (LOCAL_SYMBOL_CHECK (s))
2335 return 1;
2336 return s->sy_used;
2337 }
2338
2339 /* Mark a symbol as having been used in a reloc. */
2340
2341 void
2342 symbol_mark_used_in_reloc (symbolS *s)
2343 {
2344 if (LOCAL_SYMBOL_CHECK (s))
2345 s = local_symbol_convert ((struct local_symbol *) s);
2346 s->sy_used_in_reloc = 1;
2347 }
2348
2349 /* Clear the mark of whether a symbol has been used in a reloc. */
2350
2351 void
2352 symbol_clear_used_in_reloc (symbolS *s)
2353 {
2354 if (LOCAL_SYMBOL_CHECK (s))
2355 return;
2356 s->sy_used_in_reloc = 0;
2357 }
2358
2359 /* Return whether a symbol has been used in a reloc. */
2360
2361 int
2362 symbol_used_in_reloc_p (symbolS *s)
2363 {
2364 if (LOCAL_SYMBOL_CHECK (s))
2365 return 0;
2366 return s->sy_used_in_reloc;
2367 }
2368
2369 /* Mark a symbol as an MRI common symbol. */
2370
2371 void
2372 symbol_mark_mri_common (symbolS *s)
2373 {
2374 if (LOCAL_SYMBOL_CHECK (s))
2375 s = local_symbol_convert ((struct local_symbol *) s);
2376 s->sy_mri_common = 1;
2377 }
2378
2379 /* Clear the mark of whether a symbol is an MRI common symbol. */
2380
2381 void
2382 symbol_clear_mri_common (symbolS *s)
2383 {
2384 if (LOCAL_SYMBOL_CHECK (s))
2385 return;
2386 s->sy_mri_common = 0;
2387 }
2388
2389 /* Return whether a symbol is an MRI common symbol. */
2390
2391 int
2392 symbol_mri_common_p (symbolS *s)
2393 {
2394 if (LOCAL_SYMBOL_CHECK (s))
2395 return 0;
2396 return s->sy_mri_common;
2397 }
2398
2399 /* Mark a symbol as having been written. */
2400
2401 void
2402 symbol_mark_written (symbolS *s)
2403 {
2404 if (LOCAL_SYMBOL_CHECK (s))
2405 return;
2406 s->written = 1;
2407 }
2408
2409 /* Clear the mark of whether a symbol has been written. */
2410
2411 void
2412 symbol_clear_written (symbolS *s)
2413 {
2414 if (LOCAL_SYMBOL_CHECK (s))
2415 return;
2416 s->written = 0;
2417 }
2418
2419 /* Return whether a symbol has been written. */
2420
2421 int
2422 symbol_written_p (symbolS *s)
2423 {
2424 if (LOCAL_SYMBOL_CHECK (s))
2425 return 0;
2426 return s->written;
2427 }
2428
2429 /* Mark a symbol has having been resolved. */
2430
2431 void
2432 symbol_mark_resolved (symbolS *s)
2433 {
2434 if (LOCAL_SYMBOL_CHECK (s))
2435 {
2436 local_symbol_mark_resolved ((struct local_symbol *) s);
2437 return;
2438 }
2439 s->sy_resolved = 1;
2440 }
2441
2442 /* Return whether a symbol has been resolved. */
2443
2444 int
2445 symbol_resolved_p (symbolS *s)
2446 {
2447 if (LOCAL_SYMBOL_CHECK (s))
2448 return local_symbol_resolved_p ((struct local_symbol *) s);
2449 return s->sy_resolved;
2450 }
2451
2452 /* Return whether a symbol is a section symbol. */
2453
2454 int
2455 symbol_section_p (symbolS *s ATTRIBUTE_UNUSED)
2456 {
2457 if (LOCAL_SYMBOL_CHECK (s))
2458 return 0;
2459 return (s->bsym->flags & BSF_SECTION_SYM) != 0;
2460 }
2461
2462 /* Return whether a symbol is equated to another symbol. */
2463
2464 int
2465 symbol_equated_p (symbolS *s)
2466 {
2467 if (LOCAL_SYMBOL_CHECK (s))
2468 return 0;
2469 return s->sy_value.X_op == O_symbol;
2470 }
2471
2472 /* Return whether a symbol is equated to another symbol, and should be
2473 treated specially when writing out relocs. */
2474
2475 int
2476 symbol_equated_reloc_p (symbolS *s)
2477 {
2478 if (LOCAL_SYMBOL_CHECK (s))
2479 return 0;
2480 /* X_op_symbol, normally not used for O_symbol, is set by
2481 resolve_symbol_value to flag expression syms that have been
2482 equated. */
2483 return (s->sy_value.X_op == O_symbol
2484 #if defined (OBJ_COFF) && defined (TE_PE)
2485 && ! S_IS_WEAK (s)
2486 #endif
2487 && ((s->sy_resolved && s->sy_value.X_op_symbol != NULL)
2488 || ! S_IS_DEFINED (s)
2489 || S_IS_COMMON (s)));
2490 }
2491
2492 /* Return whether a symbol has a constant value. */
2493
2494 int
2495 symbol_constant_p (symbolS *s)
2496 {
2497 if (LOCAL_SYMBOL_CHECK (s))
2498 return 1;
2499 return s->sy_value.X_op == O_constant;
2500 }
2501
2502 /* Return the BFD symbol for a symbol. */
2503
2504 asymbol *
2505 symbol_get_bfdsym (symbolS *s)
2506 {
2507 if (LOCAL_SYMBOL_CHECK (s))
2508 s = local_symbol_convert ((struct local_symbol *) s);
2509 return s->bsym;
2510 }
2511
2512 /* Set the BFD symbol for a symbol. */
2513
2514 void
2515 symbol_set_bfdsym (symbolS *s, asymbol *bsym)
2516 {
2517 if (LOCAL_SYMBOL_CHECK (s))
2518 s = local_symbol_convert ((struct local_symbol *) s);
2519 /* Usually, it is harmless to reset a symbol to a BFD section
2520 symbol. For example, obj_elf_change_section sets the BFD symbol
2521 of an old symbol with the newly created section symbol. But when
2522 we have multiple sections with the same name, the newly created
2523 section may have the same name as an old section. We check if the
2524 old symbol has been already marked as a section symbol before
2525 resetting it. */
2526 if ((s->bsym->flags & BSF_SECTION_SYM) == 0)
2527 s->bsym = bsym;
2528 /* else XXX - What do we do now ? */
2529 }
2530
2531 #ifdef OBJ_SYMFIELD_TYPE
2532
2533 /* Get a pointer to the object format information for a symbol. */
2534
2535 OBJ_SYMFIELD_TYPE *
2536 symbol_get_obj (symbolS *s)
2537 {
2538 if (LOCAL_SYMBOL_CHECK (s))
2539 s = local_symbol_convert ((struct local_symbol *) s);
2540 return &s->sy_obj;
2541 }
2542
2543 /* Set the object format information for a symbol. */
2544
2545 void
2546 symbol_set_obj (symbolS *s, OBJ_SYMFIELD_TYPE *o)
2547 {
2548 if (LOCAL_SYMBOL_CHECK (s))
2549 s = local_symbol_convert ((struct local_symbol *) s);
2550 s->sy_obj = *o;
2551 }
2552
2553 #endif /* OBJ_SYMFIELD_TYPE */
2554
2555 #ifdef TC_SYMFIELD_TYPE
2556
2557 /* Get a pointer to the processor information for a symbol. */
2558
2559 TC_SYMFIELD_TYPE *
2560 symbol_get_tc (symbolS *s)
2561 {
2562 if (LOCAL_SYMBOL_CHECK (s))
2563 s = local_symbol_convert ((struct local_symbol *) s);
2564 return &s->sy_tc;
2565 }
2566
2567 /* Set the processor information for a symbol. */
2568
2569 void
2570 symbol_set_tc (symbolS *s, TC_SYMFIELD_TYPE *o)
2571 {
2572 if (LOCAL_SYMBOL_CHECK (s))
2573 s = local_symbol_convert ((struct local_symbol *) s);
2574 s->sy_tc = *o;
2575 }
2576
2577 #endif /* TC_SYMFIELD_TYPE */
2578
2579 void
2580 symbol_begin (void)
2581 {
2582 symbol_lastP = NULL;
2583 symbol_rootP = NULL; /* In case we have 0 symbols (!!) */
2584 sy_hash = hash_new ();
2585 local_hash = hash_new ();
2586
2587 memset ((char *) (&abs_symbol), '\0', sizeof (abs_symbol));
2588 #if defined (EMIT_SECTION_SYMBOLS) || !defined (RELOC_REQUIRES_SYMBOL)
2589 abs_symbol.bsym = bfd_abs_section.symbol;
2590 #endif
2591 abs_symbol.sy_value.X_op = O_constant;
2592 abs_symbol.sy_frag = &zero_address_frag;
2593
2594 if (LOCAL_LABELS_FB)
2595 fb_label_init ();
2596 }
2597 \f
2598 int indent_level;
2599
2600 /* Maximum indent level.
2601 Available for modification inside a gdb session. */
2602 static int max_indent_level = 8;
2603
2604 void
2605 print_symbol_value_1 (FILE *file, symbolS *sym)
2606 {
2607 const char *name = S_GET_NAME (sym);
2608 if (!name || !name[0])
2609 name = "(unnamed)";
2610 fprintf (file, "sym %lx %s", (unsigned long) sym, name);
2611
2612 if (LOCAL_SYMBOL_CHECK (sym))
2613 {
2614 struct local_symbol *locsym = (struct local_symbol *) sym;
2615 if (local_symbol_get_frag (locsym) != &zero_address_frag
2616 && local_symbol_get_frag (locsym) != NULL)
2617 fprintf (file, " frag %lx", (long) local_symbol_get_frag (locsym));
2618 if (local_symbol_resolved_p (locsym))
2619 fprintf (file, " resolved");
2620 fprintf (file, " local");
2621 }
2622 else
2623 {
2624 if (sym->sy_frag != &zero_address_frag)
2625 fprintf (file, " frag %lx", (long) sym->sy_frag);
2626 if (sym->written)
2627 fprintf (file, " written");
2628 if (sym->sy_resolved)
2629 fprintf (file, " resolved");
2630 else if (sym->sy_resolving)
2631 fprintf (file, " resolving");
2632 if (sym->sy_used_in_reloc)
2633 fprintf (file, " used-in-reloc");
2634 if (sym->sy_used)
2635 fprintf (file, " used");
2636 if (S_IS_LOCAL (sym))
2637 fprintf (file, " local");
2638 if (S_IS_EXTERNAL (sym))
2639 fprintf (file, " extern");
2640 if (S_IS_WEAK (sym))
2641 fprintf (file, " weak");
2642 if (S_IS_DEBUG (sym))
2643 fprintf (file, " debug");
2644 if (S_IS_DEFINED (sym))
2645 fprintf (file, " defined");
2646 }
2647 if (S_IS_WEAKREFR (sym))
2648 fprintf (file, " weakrefr");
2649 if (S_IS_WEAKREFD (sym))
2650 fprintf (file, " weakrefd");
2651 fprintf (file, " %s", segment_name (S_GET_SEGMENT (sym)));
2652 if (symbol_resolved_p (sym))
2653 {
2654 segT s = S_GET_SEGMENT (sym);
2655
2656 if (s != undefined_section
2657 && s != expr_section)
2658 fprintf (file, " %lx", (long) S_GET_VALUE (sym));
2659 }
2660 else if (indent_level < max_indent_level
2661 && S_GET_SEGMENT (sym) != undefined_section)
2662 {
2663 indent_level++;
2664 fprintf (file, "\n%*s<", indent_level * 4, "");
2665 if (LOCAL_SYMBOL_CHECK (sym))
2666 fprintf (file, "constant %lx",
2667 (long) ((struct local_symbol *) sym)->lsy_value);
2668 else
2669 print_expr_1 (file, &sym->sy_value);
2670 fprintf (file, ">");
2671 indent_level--;
2672 }
2673 fflush (file);
2674 }
2675
2676 void
2677 print_symbol_value (symbolS *sym)
2678 {
2679 indent_level = 0;
2680 print_symbol_value_1 (stderr, sym);
2681 fprintf (stderr, "\n");
2682 }
2683
2684 static void
2685 print_binary (FILE *file, const char *name, expressionS *exp)
2686 {
2687 indent_level++;
2688 fprintf (file, "%s\n%*s<", name, indent_level * 4, "");
2689 print_symbol_value_1 (file, exp->X_add_symbol);
2690 fprintf (file, ">\n%*s<", indent_level * 4, "");
2691 print_symbol_value_1 (file, exp->X_op_symbol);
2692 fprintf (file, ">");
2693 indent_level--;
2694 }
2695
2696 void
2697 print_expr_1 (FILE *file, expressionS *exp)
2698 {
2699 fprintf (file, "expr %lx ", (long) exp);
2700 switch (exp->X_op)
2701 {
2702 case O_illegal:
2703 fprintf (file, "illegal");
2704 break;
2705 case O_absent:
2706 fprintf (file, "absent");
2707 break;
2708 case O_constant:
2709 fprintf (file, "constant %lx", (long) exp->X_add_number);
2710 break;
2711 case O_symbol:
2712 indent_level++;
2713 fprintf (file, "symbol\n%*s<", indent_level * 4, "");
2714 print_symbol_value_1 (file, exp->X_add_symbol);
2715 fprintf (file, ">");
2716 maybe_print_addnum:
2717 if (exp->X_add_number)
2718 fprintf (file, "\n%*s%lx", indent_level * 4, "",
2719 (long) exp->X_add_number);
2720 indent_level--;
2721 break;
2722 case O_register:
2723 fprintf (file, "register #%d", (int) exp->X_add_number);
2724 break;
2725 case O_big:
2726 fprintf (file, "big");
2727 break;
2728 case O_uminus:
2729 fprintf (file, "uminus -<");
2730 indent_level++;
2731 print_symbol_value_1 (file, exp->X_add_symbol);
2732 fprintf (file, ">");
2733 goto maybe_print_addnum;
2734 case O_bit_not:
2735 fprintf (file, "bit_not");
2736 break;
2737 case O_multiply:
2738 print_binary (file, "multiply", exp);
2739 break;
2740 case O_divide:
2741 print_binary (file, "divide", exp);
2742 break;
2743 case O_modulus:
2744 print_binary (file, "modulus", exp);
2745 break;
2746 case O_left_shift:
2747 print_binary (file, "lshift", exp);
2748 break;
2749 case O_right_shift:
2750 print_binary (file, "rshift", exp);
2751 break;
2752 case O_bit_inclusive_or:
2753 print_binary (file, "bit_ior", exp);
2754 break;
2755 case O_bit_exclusive_or:
2756 print_binary (file, "bit_xor", exp);
2757 break;
2758 case O_bit_and:
2759 print_binary (file, "bit_and", exp);
2760 break;
2761 case O_eq:
2762 print_binary (file, "eq", exp);
2763 break;
2764 case O_ne:
2765 print_binary (file, "ne", exp);
2766 break;
2767 case O_lt:
2768 print_binary (file, "lt", exp);
2769 break;
2770 case O_le:
2771 print_binary (file, "le", exp);
2772 break;
2773 case O_ge:
2774 print_binary (file, "ge", exp);
2775 break;
2776 case O_gt:
2777 print_binary (file, "gt", exp);
2778 break;
2779 case O_logical_and:
2780 print_binary (file, "logical_and", exp);
2781 break;
2782 case O_logical_or:
2783 print_binary (file, "logical_or", exp);
2784 break;
2785 case O_add:
2786 indent_level++;
2787 fprintf (file, "add\n%*s<", indent_level * 4, "");
2788 print_symbol_value_1 (file, exp->X_add_symbol);
2789 fprintf (file, ">\n%*s<", indent_level * 4, "");
2790 print_symbol_value_1 (file, exp->X_op_symbol);
2791 fprintf (file, ">");
2792 goto maybe_print_addnum;
2793 case O_subtract:
2794 indent_level++;
2795 fprintf (file, "subtract\n%*s<", indent_level * 4, "");
2796 print_symbol_value_1 (file, exp->X_add_symbol);
2797 fprintf (file, ">\n%*s<", indent_level * 4, "");
2798 print_symbol_value_1 (file, exp->X_op_symbol);
2799 fprintf (file, ">");
2800 goto maybe_print_addnum;
2801 default:
2802 fprintf (file, "{unknown opcode %d}", (int) exp->X_op);
2803 break;
2804 }
2805 fflush (stdout);
2806 }
2807
2808 void
2809 print_expr (expressionS *exp)
2810 {
2811 print_expr_1 (stderr, exp);
2812 fprintf (stderr, "\n");
2813 }
2814
2815 void
2816 symbol_print_statistics (FILE *file)
2817 {
2818 hash_print_statistics (file, "symbol table", sy_hash);
2819 hash_print_statistics (file, "mini local symbol table", local_hash);
2820 fprintf (file, "%lu mini local symbols created, %lu converted\n",
2821 local_symbol_count, local_symbol_conversion_count);
2822 }
This page took 0.114828 seconds and 5 git commands to generate.