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