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