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