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