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