projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
*** empty log message ***
[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,
885afe7b 3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
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
10 the Free Software Foundation; either version 2, or (at your option)
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
NC		 565
566 know (S_IS_DEFINED (orgsymP));
567
568 newsymP = obstack_alloc (&notes, sizeof (*newsymP));
569 *newsymP = *orgsymP;
6a2b6326
JB		 570 bsymnew = bfd_make_empty_symbol (bfd_asymbol_bfd (bsymorg));
571 if (bsymnew == NULL)
885afe7b 572 as_fatal ("bfd_make_empty_symbol: %s", bfd_errmsg (bfd_get_error ()));
6a2b6326
JB		 573 newsymP->bsym = bsymnew;
574 bsymnew->name = bsymorg->name;
575 bsymnew->flags = bsymorg->flags;
576 bsymnew->section = bsymorg->section;
6a2b6326
JB		 577 bfd_copy_private_symbol_data (bfd_asymbol_bfd (bsymorg), bsymorg,
578 bfd_asymbol_bfd (bsymnew), bsymnew);
579
580#ifdef obj_symbol_clone_hook
581 obj_symbol_clone_hook (newsymP, orgsymP);
582#endif
583
584#ifdef tc_symbol_clone_hook
585 tc_symbol_clone_hook (newsymP, orgsymP);
586#endif
9497f5ac
NC		 587
588 if (replace)
589 {
590 if (symbol_rootP == orgsymP)
591 symbol_rootP = newsymP;
592 else if (orgsymP->sy_previous)
593 {
594 orgsymP->sy_previous->sy_next = newsymP;
595 orgsymP->sy_previous = NULL;
596 }
597 if (symbol_lastP == orgsymP)
598 symbol_lastP = newsymP;
599 else if (orgsymP->sy_next)
600 orgsymP->sy_next->sy_previous = newsymP;
bdf128d6 601 orgsymP->sy_previous = orgsymP->sy_next = orgsymP;
9497f5ac
NC		 602 debug_verify_symchain (symbol_rootP, symbol_lastP);
603
604 symbol_table_insert (newsymP);
605 }
bdf128d6
JB		 606 else
607 newsymP->sy_previous = newsymP->sy_next = newsymP;
9497f5ac
NC		 608
609 return newsymP;
610}
611
612/* Referenced symbols, if they are forward references, need to be cloned
613 (without replacing the original) so that the value of the referenced
614 symbols at the point of use . */
615
616#undef symbol_clone_if_forward_ref
617symbolS *
618symbol_clone_if_forward_ref (symbolS *symbolP, int is_forward)
619{
620 if (symbolP && !LOCAL_SYMBOL_CHECK (symbolP))
621 {
622 symbolS *add_symbol = symbolP->sy_value.X_add_symbol;
623 symbolS *op_symbol = symbolP->sy_value.X_op_symbol;
624
625 if (symbolP->sy_forward_ref)
626 is_forward = 1;
627
628 if (is_forward)
629 {
630 /* assign_symbol() clones volatile symbols; pre-existing expressions
631 hold references to the original instance, but want the current
632 value. Just repeat the lookup. */
633 if (add_symbol && S_IS_VOLATILE (add_symbol))
634 add_symbol = symbol_find_exact (S_GET_NAME (add_symbol));
635 if (op_symbol && S_IS_VOLATILE (op_symbol))
636 op_symbol = symbol_find_exact (S_GET_NAME (op_symbol));
637 }
638
639 /* Re-using sy_resolving here, as this routine cannot get called from
640 symbol resolution code. */
641 if (symbolP->bsym->section == expr_section && !symbolP->sy_resolving)
642 {
643 symbolP->sy_resolving = 1;
644 add_symbol = symbol_clone_if_forward_ref (add_symbol, is_forward);
645 op_symbol = symbol_clone_if_forward_ref (op_symbol, is_forward);
646 symbolP->sy_resolving = 0;
647 }
648
649 if (symbolP->sy_forward_ref
650 || add_symbol != symbolP->sy_value.X_add_symbol
651 || op_symbol != symbolP->sy_value.X_op_symbol)
652 symbolP = symbol_clone (symbolP, 0);
653
654 symbolP->sy_value.X_add_symbol = add_symbol;
655 symbolP->sy_value.X_op_symbol = op_symbol;
656 }
657
658 return symbolP;
659}
660
b7d6ed97 661symbolS *
74937d39 662symbol_temp_new (segT seg, valueT ofs, fragS *frag)
b7d6ed97 663{
756d1d01 664 return symbol_new (FAKE_LABEL_NAME, seg, ofs, frag);
b7d6ed97
RH		 665}
666
667symbolS *
74937d39 668symbol_temp_new_now (void)
b7d6ed97
RH		 669{
670 return symbol_temp_new (now_seg, frag_now_fix (), frag_now);
671}
672
673symbolS *
74937d39 674symbol_temp_make (void)
b7d6ed97 675{
756d1d01 676 return symbol_make (FAKE_LABEL_NAME);
b7d6ed97
RH		 677}
678
7c743825
KH		 679/* Implement symbol table lookup.
680 In: A symbol's name as a string: '\0' can't be part of a symbol name.
681 Out: NULL if the name was not in the symbol table, else the address
682 of a struct symbol associated with that name. */
252b5132 683
9758f3fc 684symbolS *
74937d39 685symbol_find_exact (const char *name)
06e77878
AO		 686{
687 return symbol_find_exact_noref (name, 0);
688}
689
690symbolS *
691symbol_find_exact_noref (const char *name, int noref)
9758f3fc 692{
7be1c489 693 struct local_symbol *locsym;
06e77878 694 symbolS* sym;
9758f3fc 695
7be1c489
AM		 696 locsym = (struct local_symbol *) hash_find (local_hash, name);
697 if (locsym != NULL)
698 return (symbolS *) locsym;
9758f3fc 699
06e77878
AO		 700 sym = ((symbolS *) hash_find (sy_hash, name));
701
702 /* Any references to the symbol, except for the reference in
703 .weakref, must clear this flag, such that the symbol does not
704 turn into a weak symbol. Note that we don't have to handle the
705 local_symbol case, since a weakrefd is always promoted out of the
706 local_symbol table when it is turned into a weak symbol. */
707 if (sym && ! noref)
708 S_CLEAR_WEAKREFD (sym);
709
710 return sym;
9758f3fc
AM		 711}
712
252b5132 713symbolS *
91c4c449 714symbol_find (const char *name)
06e77878
AO		 715{
716 return symbol_find_noref (name, 0);
717}
718
719symbolS *
720symbol_find_noref (const char *name, int noref)
252b5132 721{
252b5132
RH		 722#ifdef tc_canonicalize_symbol_name
723 {
724 char *copy;
03987ced 725 size_t len = strlen (name) + 1;
252b5132 726
03987ced
RH		 727 copy = (char *) alloca (len);
728 memcpy (copy, name, len);
252b5132
RH		 729 name = tc_canonicalize_symbol_name (copy);
730 }
731#endif
732
733 if (! symbols_case_sensitive)
734 {
03987ced
RH		 735 char *copy;
736 const char *orig;
737 unsigned char c;
738
739 orig = name;
740 name = copy = (char *) alloca (strlen (name) + 1);
741
742 while ((c = *orig++) != '\0')
743 {
3882b010 744 *copy++ = TOUPPER (c);
03987ced
RH		 745 }
746 *copy = '\0';
252b5132
RH		 747 }
748
06e77878 749 return symbol_find_exact_noref (name, noref);
252b5132
RH		 750}
751
7c743825
KH		 752/* Once upon a time, symbols were kept in a singly linked list. At
753 least coff needs to be able to rearrange them from time to time, for
754 which a doubly linked list is much more convenient. Loic did these
755 as macros which seemed dangerous to me so they're now functions.
756 xoxorich. */
757
758/* Link symbol ADDME after symbol TARGET in the chain. */
252b5132 759
7c743825 760void
74937d39
KH		 761symbol_append (symbolS *addme, symbolS *target,
762 symbolS **rootPP, symbolS **lastPP)
252b5132 763{
49309057
ILT		 764 if (LOCAL_SYMBOL_CHECK (addme))
765 abort ();
766 if (target != NULL && LOCAL_SYMBOL_CHECK (target))
767 abort ();
768
252b5132
RH		 769 if (target == NULL)
770 {
771 know (*rootPP == NULL);
772 know (*lastPP == NULL);
773 addme->sy_next = NULL;
252b5132 774 addme->sy_previous = NULL;
252b5132
RH		 775 *rootPP = addme;
776 *lastPP = addme;
777 return;
7c743825 778 } /* if the list is empty */
252b5132
RH		 779
780 if (target->sy_next != NULL)
781 {
252b5132 782 target->sy_next->sy_previous = addme;
252b5132
RH		 783 }
784 else
785 {
786 know (*lastPP == target);
787 *lastPP = addme;
7c743825 788 } /* if we have a next */
252b5132
RH		 789
790 addme->sy_next = target->sy_next;
791 target->sy_next = addme;
252b5132 792 addme->sy_previous = target;
252b5132
RH		 793
794 debug_verify_symchain (symbol_rootP, symbol_lastP);
795}
796
7c743825
KH		 797/* Set the chain pointers of SYMBOL to null. */
798
799void
74937d39 800symbol_clear_list_pointers (symbolS *symbolP)
252b5132 801{
49309057
ILT		 802 if (LOCAL_SYMBOL_CHECK (symbolP))
803 abort ();
252b5132 804 symbolP->sy_next = NULL;
252b5132 805 symbolP->sy_previous = NULL;
252b5132
RH		 806}
807
7c743825
KH		 808/* Remove SYMBOLP from the list. */
809
810void
74937d39 811symbol_remove (symbolS *symbolP, symbolS **rootPP, symbolS **lastPP)
252b5132 812{
49309057
ILT		 813 if (LOCAL_SYMBOL_CHECK (symbolP))
814 abort ();
815
252b5132
RH		 816 if (symbolP == *rootPP)
817 {
818 *rootPP = symbolP->sy_next;
7c743825 819 } /* if it was the root */
252b5132
RH		 820
821 if (symbolP == *lastPP)
822 {
823 *lastPP = symbolP->sy_previous;
7c743825 824 } /* if it was the tail */
252b5132
RH		 825
826 if (symbolP->sy_next != NULL)
827 {
828 symbolP->sy_next->sy_previous = symbolP->sy_previous;
7c743825 829 } /* if not last */
252b5132
RH		 830
831 if (symbolP->sy_previous != NULL)
832 {
833 symbolP->sy_previous->sy_next = symbolP->sy_next;
7c743825 834 } /* if not first */
252b5132
RH		 835
836 debug_verify_symchain (*rootPP, *lastPP);
837}
838
7c743825
KH		 839/* Link symbol ADDME before symbol TARGET in the chain. */
840
841void
74937d39
KH		 842symbol_insert (symbolS *addme, symbolS *target,
843 symbolS **rootPP, symbolS **lastPP ATTRIBUTE_UNUSED)
252b5132 844{
49309057
ILT		 845 if (LOCAL_SYMBOL_CHECK (addme))
846 abort ();
847 if (LOCAL_SYMBOL_CHECK (target))
848 abort ();
849
252b5132
RH		 850 if (target->sy_previous != NULL)
851 {
852 target->sy_previous->sy_next = addme;
853 }
854 else
855 {
856 know (*rootPP == target);
857 *rootPP = addme;
7c743825 858 } /* if not first */
252b5132
RH		 859
860 addme->sy_previous = target->sy_previous;
861 target->sy_previous = addme;
862 addme->sy_next = target;
863
864 debug_verify_symchain (*rootPP, *lastPP);
865}
866
7c743825 867void
74937d39 868verify_symbol_chain (symbolS *rootP, symbolS *lastP)
252b5132
RH		 869{
870 symbolS *symbolP = rootP;
871
872 if (symbolP == NULL)
873 return;
874
875 for (; symbol_next (symbolP) != NULL; symbolP = symbol_next (symbolP))
876 {
49309057 877 assert (symbolP->bsym != NULL);
252b5132 878 assert (symbolP->sy_next->sy_previous == symbolP);
252b5132
RH		 879 }
880
881 assert (lastP == symbolP);
882}
883
280d71bf
DB		 884#ifdef OBJ_COMPLEX_RELC
885
886static int
887use_complex_relocs_for (symbolS * symp)
888{
889 switch (symp->sy_value.X_op)
890 {
891 case O_constant:
892 return 0;
893
894 case O_symbol:
895 case O_symbol_rva:
896 case O_uminus:
897 case O_bit_not:
898 case O_logical_not:
899 if ( (S_IS_COMMON (symp->sy_value.X_add_symbol)
900 || S_IS_LOCAL (symp->sy_value.X_add_symbol))
901 &&
902 (S_IS_DEFINED (symp->sy_value.X_add_symbol)
903 && S_GET_SEGMENT (symp->sy_value.X_add_symbol) != expr_section))
904 return 0;
905 break;
906
907 case O_multiply:
908 case O_divide:
909 case O_modulus:
910 case O_left_shift:
911 case O_right_shift:
912 case O_bit_inclusive_or:
913 case O_bit_or_not:
914 case O_bit_exclusive_or:
915 case O_bit_and:
916 case O_add:
917 case O_subtract:
918 case O_eq:
919 case O_ne:
920 case O_lt:
921 case O_le:
922 case O_ge:
923 case O_gt:
924 case O_logical_and:
925 case O_logical_or:
926
927 if ( (S_IS_COMMON (symp->sy_value.X_add_symbol)
928 || S_IS_LOCAL (symp->sy_value.X_add_symbol))
929 &&
930 (S_IS_COMMON (symp->sy_value.X_op_symbol)
931 || S_IS_LOCAL (symp->sy_value.X_op_symbol))
932
933 && S_IS_DEFINED (symp->sy_value.X_add_symbol)
934 && S_IS_DEFINED (symp->sy_value.X_op_symbol)
935 && S_GET_SEGMENT (symp->sy_value.X_add_symbol) != expr_section
936 && S_GET_SEGMENT (symp->sy_value.X_op_symbol) != expr_section)
937 return 0;
938 break;
939
940 default:
941 break;
942 }
943 return 1;
944}
945#endif
946
0909233e 947static void
74937d39 948report_op_error (symbolS *symp, symbolS *left, symbolS *right)
0909233e
AM		 949{
950 char *file;
951 unsigned int line;
952 segT seg_left = S_GET_SEGMENT (left);
953 segT seg_right = right ? S_GET_SEGMENT (right) : 0;
1d3b2b27 954
0909233e
AM		 955 if (expr_symbol_where (symp, &file, &line))
956 {
957 if (seg_left == undefined_section)
958 as_bad_where (file, line,
959 _("undefined symbol `%s' in operation"),
960 S_GET_NAME (left));
961 if (seg_right == undefined_section)
962 as_bad_where (file, line,
963 _("undefined symbol `%s' in operation"),
964 S_GET_NAME (right));
965 if (seg_left != undefined_section
966 && seg_right != undefined_section)
967 {
968 if (right)
969 as_bad_where (file, line,
970 _("invalid sections for operation on `%s' and `%s'"),
971 S_GET_NAME (left), S_GET_NAME (right));
972 else
973 as_bad_where (file, line,
974 _("invalid section for operation on `%s'"),
975 S_GET_NAME (left));
976 }
1d3b2b27 977
0909233e
AM		 978 }
979 else
980 {
981 if (seg_left == undefined_section)
982 as_bad (_("undefined symbol `%s' in operation setting `%s'"),
983 S_GET_NAME (left), S_GET_NAME (symp));
984 if (seg_right == undefined_section)
985 as_bad (_("undefined symbol `%s' in operation setting `%s'"),
986 S_GET_NAME (right), S_GET_NAME (symp));
987 if (seg_left != undefined_section
988 && seg_right != undefined_section)
989 {
990 if (right)
d9e05e4e
AM		 991 as_bad (_("invalid sections for operation on `%s' and `%s' setting `%s'"),
992 S_GET_NAME (left), S_GET_NAME (right), S_GET_NAME (symp));
0909233e 993 else
d9e05e4e
AM		 994 as_bad (_("invalid section for operation on `%s' setting `%s'"),
995 S_GET_NAME (left), S_GET_NAME (symp));
0909233e
AM		 996 }
997 }
998}
999
252b5132
RH		 1000/* Resolve the value of a symbol. This is called during the final
1001 pass over the symbol table to resolve any symbols with complex
1002 values. */
1003
1004valueT
74937d39 1005resolve_symbol_value (symbolS *symp)
252b5132
RH		 1006{
1007 int resolved;
03e83a45 1008 valueT final_val = 0;
252b5132
RH		 1009 segT final_seg;
1010
49309057
ILT		 1011 if (LOCAL_SYMBOL_CHECK (symp))
1012 {
1013 struct local_symbol *locsym = (struct local_symbol *) symp;
1014
bd780143 1015 final_val = locsym->lsy_value;
49309057 1016 if (local_symbol_resolved_p (locsym))
bd780143 1017 return final_val;
49309057 1018
bd780143 1019 final_val += local_symbol_get_frag (locsym)->fr_address / OCTETS_PER_BYTE;
49309057 1020
6386f3a7 1021 if (finalize_syms)
49309057 1022 {
bd780143 1023 locsym->lsy_value = final_val;
49309057
ILT		 1024 local_symbol_mark_resolved (locsym);
1025 }
1026
1027 return final_val;
1028 }
1029
252b5132
RH		 1030 if (symp->sy_resolved)
1031 {
1032 if (symp->sy_value.X_op == O_constant)
1033 return (valueT) symp->sy_value.X_add_number;
1034 else
1035 return 0;
1036 }
1037
1038 resolved = 0;
1039 final_seg = S_GET_SEGMENT (symp);
1040
1041 if (symp->sy_resolving)
1042 {
6386f3a7 1043 if (finalize_syms)
0e389e77 1044 as_bad (_("symbol definition loop encountered at `%s'"),
7c743825 1045 S_GET_NAME (symp));
252b5132
RH		 1046 final_val = 0;
1047 resolved = 1;
1048 }
280d71bf
DB		 1049#ifdef OBJ_COMPLEX_RELC
1050 else if (final_seg == expr_section
1051 && use_complex_relocs_for (symp))
1052 {
1053 symbolS * relc_symbol = NULL;
1054 char * relc_symbol_name = NULL;
1055
1056 relc_symbol_name = symbol_relc_make_expr (& symp->sy_value);
1057
1058 /* For debugging, print out conversion input & output. */
1059#ifdef DEBUG_SYMS
1060 print_expr (& symp->sy_value);
1061 if (relc_symbol_name)
1062 fprintf (stderr, "-> relc symbol: %s\n", relc_symbol_name);
1063#endif
1064
1065 if (relc_symbol_name != NULL)
1066 relc_symbol = symbol_new (relc_symbol_name, undefined_section,
1067 0, & zero_address_frag);
1068
1069 if (relc_symbol == NULL)
1070 {
1071 as_bad (_("cannot convert expression symbol %s to complex relocation"),
1072 S_GET_NAME (symp));
1073 resolved = 0;
1074 }
1075 else
1076 {
1077 symbol_table_insert (relc_symbol);
1078
1079 /* S_CLEAR_EXTERNAL (relc_symbol); */
1080 if (symp->bsym->flags & BSF_SRELC)
1081 relc_symbol->bsym->flags |= BSF_SRELC;
1082 else
1083 relc_symbol->bsym->flags |= BSF_RELC;
1084 /* symp->bsym->flags |= BSF_RELC; */
1085 copy_symbol_attributes (symp, relc_symbol);
1086 symp->sy_value.X_op = O_symbol;
1087 symp->sy_value.X_add_symbol = relc_symbol;
1088 symp->sy_value.X_add_number = 0;
1089 resolved = 1;
1090 }
1091
1092 final_seg = undefined_section;
1093 goto exit_dont_set_value;
1094 }
1095#endif
252b5132
RH		 1096 else
1097 {
1098 symbolS *add_symbol, *op_symbol;
1099 offsetT left, right;
1100 segT seg_left, seg_right;
1101 operatorT op;
2d034539 1102 int move_seg_ok;
252b5132
RH		 1103
1104 symp->sy_resolving = 1;
1105
1106 /* Help out with CSE. */
1107 add_symbol = symp->sy_value.X_add_symbol;
1108 op_symbol = symp->sy_value.X_op_symbol;
1109 final_val = symp->sy_value.X_add_number;
1110 op = symp->sy_value.X_op;
1111
1112 switch (op)
1113 {
1114 default:
1115 BAD_CASE (op);
1116 break;
1117
1118 case O_absent:
1119 final_val = 0;
1120 /* Fall through. */
1121
1122 case O_constant:
bea9907b 1123 final_val += symp->sy_frag->fr_address / OCTETS_PER_BYTE;
252b5132
RH		 1124 if (final_seg == expr_section)
1125 final_seg = absolute_section;
1126 resolved = 1;
1127 break;
1128
1129 case O_symbol:
1130 case O_symbol_rva:
6386f3a7 1131 left = resolve_symbol_value (add_symbol);
e0890092
AM		 1132 seg_left = S_GET_SEGMENT (add_symbol);
1133 if (finalize_syms)
1134 symp->sy_value.X_op_symbol = NULL;
252b5132 1135
e0890092 1136 do_symbol:
06e77878
AO		 1137 if (S_IS_WEAKREFR (symp))
1138 {
1139 assert (final_val == 0);
1140 if (S_IS_WEAKREFR (add_symbol))
1141 {
1142 assert (add_symbol->sy_value.X_op == O_symbol
1143 && add_symbol->sy_value.X_add_number == 0);
1144 add_symbol = add_symbol->sy_value.X_add_symbol;
1145 assert (! S_IS_WEAKREFR (add_symbol));
1146 symp->sy_value.X_add_symbol = add_symbol;
1147 }
1148 }
1149
252b5132
RH		 1150 if (symp->sy_mri_common)
1151 {
1152 /* This is a symbol inside an MRI common section. The
e0890092
AM		 1153 relocation routines are going to handle it specially.
1154 Don't change the value. */
49309057 1155 resolved = symbol_resolved_p (add_symbol);
252b5132
RH		 1156 break;
1157 }
1158
6386f3a7 1159 if (finalize_syms && final_val == 0)
49309057
ILT		 1160 {
1161 if (LOCAL_SYMBOL_CHECK (add_symbol))
1162 add_symbol = local_symbol_convert ((struct local_symbol *)
1163 add_symbol);
1164 copy_symbol_attributes (symp, add_symbol);
1165 }
252b5132 1166
e0890092
AM		 1167 /* If we have equated this symbol to an undefined or common
1168 symbol, keep X_op set to O_symbol, and don't change
1169 X_add_number. This permits the routine which writes out
1170 relocation to detect this case, and convert the
1171 relocation to be against the symbol to which this symbol
1172 is equated. */
977cdf5a 1173 if (! S_IS_DEFINED (add_symbol)
7be1c489 1174#if defined (OBJ_COFF) && defined (TE_PE)
977cdf5a
NC		 1175 || S_IS_WEAK (add_symbol)
1176#endif
1177 || S_IS_COMMON (add_symbol))
252b5132 1178 {
6386f3a7 1179 if (finalize_syms)
252b5132 1180 {
252b5132
RH		 1181 symp->sy_value.X_op = O_symbol;
1182 symp->sy_value.X_add_symbol = add_symbol;
1183 symp->sy_value.X_add_number = final_val;
e0890092
AM		 1184 /* Use X_op_symbol as a flag. */
1185 symp->sy_value.X_op_symbol = add_symbol;
1186 final_seg = seg_left;
252b5132
RH		 1187 }
1188 final_val = 0;
49309057 1189 resolved = symbol_resolved_p (add_symbol);
c89c8534 1190 symp->sy_resolving = 0;
252b5132
RH		 1191 goto exit_dont_set_value;
1192 }
0023dd27
AM		 1193 else if (finalize_syms
1194 && ((final_seg == expr_section && seg_left != expr_section)
1195 || symbol_shadow_p (symp)))
e0890092
AM		 1196 {
1197 /* If the symbol is an expression symbol, do similarly
1198 as for undefined and common syms above. Handles
1199 "sym +/- expr" where "expr" cannot be evaluated
1200 immediately, and we want relocations to be against
1201 "sym", eg. because it is weak. */
1202 symp->sy_value.X_op = O_symbol;
1203 symp->sy_value.X_add_symbol = add_symbol;
1204 symp->sy_value.X_add_number = final_val;
1205 symp->sy_value.X_op_symbol = add_symbol;
1206 final_seg = seg_left;
1207 final_val += symp->sy_frag->fr_address + left;
1208 resolved = symbol_resolved_p (add_symbol);
1209 symp->sy_resolving = 0;
1210 goto exit_dont_set_value;
1211 }
252b5132
RH		 1212 else
1213 {
1214 final_val += symp->sy_frag->fr_address + left;
1215 if (final_seg == expr_section || final_seg == undefined_section)
e0890092 1216 final_seg = seg_left;
252b5132
RH		 1217 }
1218
49309057 1219 resolved = symbol_resolved_p (add_symbol);
06e77878
AO		 1220 if (S_IS_WEAKREFR (symp))
1221 goto exit_dont_set_value;
252b5132
RH		 1222 break;
1223
1224 case O_uminus:
1225 case O_bit_not:
1226 case O_logical_not:
6386f3a7 1227 left = resolve_symbol_value (add_symbol);
784b640d 1228 seg_left = S_GET_SEGMENT (add_symbol);
252b5132 1229
0909233e
AM		 1230 /* By reducing these to the relevant dyadic operator, we get
1231 !S -> S == 0 permitted on anything,
1232 -S -> 0 - S only permitted on absolute
1233 ~S -> S ^ ~0 only permitted on absolute */
1234 if (op != O_logical_not && seg_left != absolute_section
1235 && finalize_syms)
1236 report_op_error (symp, add_symbol, NULL);
1d3b2b27 1237
0909233e
AM		 1238 if (final_seg == expr_section || final_seg == undefined_section)
1239 final_seg = absolute_section;
1d3b2b27 1240
252b5132
RH		 1241 if (op == O_uminus)
1242 left = -left;
1243 else if (op == O_logical_not)
1244 left = !left;
1245 else
1246 left = ~left;
1247
1248 final_val += left + symp->sy_frag->fr_address;
252b5132 1249
49309057 1250 resolved = symbol_resolved_p (add_symbol);
252b5132
RH		 1251 break;
1252
1253 case O_multiply:
1254 case O_divide:
1255 case O_modulus:
1256 case O_left_shift:
1257 case O_right_shift:
1258 case O_bit_inclusive_or:
1259 case O_bit_or_not:
1260 case O_bit_exclusive_or:
1261 case O_bit_and:
1262 case O_add:
1263 case O_subtract:
1264 case O_eq:
1265 case O_ne:
1266 case O_lt:
1267 case O_le:
1268 case O_ge:
1269 case O_gt:
1270 case O_logical_and:
1271 case O_logical_or:
6386f3a7
AM		 1272 left = resolve_symbol_value (add_symbol);
1273 right = resolve_symbol_value (op_symbol);
252b5132
RH		 1274 seg_left = S_GET_SEGMENT (add_symbol);
1275 seg_right = S_GET_SEGMENT (op_symbol);
1276
1277 /* Simplify addition or subtraction of a constant by folding the
1278 constant into X_add_number. */
e0890092 1279 if (op == O_add)
252b5132
RH		 1280 {
1281 if (seg_right == absolute_section)
1282 {
e0890092 1283 final_val += right;
252b5132
RH		 1284 goto do_symbol;
1285 }
e0890092 1286 else if (seg_left == absolute_section)
252b5132 1287 {
252b5132
RH		 1288 final_val += left;
1289 add_symbol = op_symbol;
1290 left = right;
e0890092
AM		 1291 seg_left = seg_right;
1292 goto do_symbol;
1293 }
1294 }
1295 else if (op == O_subtract)
1296 {
1297 if (seg_right == absolute_section)
1298 {
1299 final_val -= right;
252b5132
RH		 1300 goto do_symbol;
1301 }
1302 }
1303
2d034539 1304 move_seg_ok = 1;
e0890092
AM		 1305 /* Equality and non-equality tests are permitted on anything.
1306 Subtraction, and other comparison operators are permitted if
1307 both operands are in the same section. Otherwise, both
1308 operands must be absolute. We already handled the case of
1309 addition or subtraction of a constant above. This will
1310 probably need to be changed for an object file format which
2d034539
NC		 1311 supports arbitrary expressions, such as IEEE-695. */
1312 if (!(seg_left == absolute_section
0909233e
AM		 1313 && seg_right == absolute_section)
1314 && !(op == O_eq || op == O_ne)
1315 && !((op == O_subtract
1316 || op == O_lt || op == O_le || op == O_ge || op == O_gt)
1317 && seg_left == seg_right
1318 && (seg_left != undefined_section
1319 || add_symbol == op_symbol)))
2d034539
NC		 1320 {
1321 /* Don't emit messages unless we're finalizing the symbol value,
1322 otherwise we may get the same message multiple times. */
1323 if (finalize_syms)
1324 report_op_error (symp, add_symbol, op_symbol);
1325 /* However do not move the symbol into the absolute section
1326 if it cannot currently be resolved - this would confuse
1327 other parts of the assembler into believing that the
1328 expression had been evaluated to zero. */
1329 else
1330 move_seg_ok = 0;
1331 }
1d3b2b27 1332
2d034539
NC		 1333 if (move_seg_ok
1334 && (final_seg == expr_section || final_seg == undefined_section))
0909233e 1335 final_seg = absolute_section;
252b5132
RH		 1336
1337 /* Check for division by zero. */
1338 if ((op == O_divide || op == O_modulus) && right == 0)
1339 {
1340 /* If seg_right is not absolute_section, then we've
e0890092 1341 already issued a warning about using a bad symbol. */
6386f3a7 1342 if (seg_right == absolute_section && finalize_syms)
252b5132
RH		 1343 {
1344 char *file;
1345 unsigned int line;
1346
1347 if (expr_symbol_where (symp, &file, &line))
1348 as_bad_where (file, line, _("division by zero"));
1349 else
0e389e77 1350 as_bad (_("division by zero when setting `%s'"),
252b5132
RH		 1351 S_GET_NAME (symp));
1352 }
1353
1354 right = 1;
1355 }
1356
1357 switch (symp->sy_value.X_op)
1358 {
1359 case O_multiply: left *= right; break;
1360 case O_divide: left /= right; break;
1361 case O_modulus: left %= right; break;
1362 case O_left_shift: left <<= right; break;
1363 case O_right_shift: left >>= right; break;
1364 case O_bit_inclusive_or: left |= right; break;
1365 case O_bit_or_not: left |= ~right; break;
1366 case O_bit_exclusive_or: left ^= right; break;
1367 case O_bit_and: left &= right; break;
1368 case O_add: left += right; break;
1369 case O_subtract: left -= right; break;
e0890092
AM		 1370 case O_eq:
1371 case O_ne:
1372 left = (left == right && seg_left == seg_right
1373 && (seg_left != undefined_section
1374 || add_symbol == op_symbol)
1375 ? ~ (offsetT) 0 : 0);
1376 if (symp->sy_value.X_op == O_ne)
1377 left = ~left;
1378 break;
252b5132
RH		 1379 case O_lt: left = left < right ? ~ (offsetT) 0 : 0; break;
1380 case O_le: left = left <= right ? ~ (offsetT) 0 : 0; break;
1381 case O_ge: left = left >= right ? ~ (offsetT) 0 : 0; break;
1382 case O_gt: left = left > right ? ~ (offsetT) 0 : 0; break;
1383 case O_logical_and: left = left && right; break;
1384 case O_logical_or: left = left || right; break;
1385 default: abort ();
1386 }
1387
1388 final_val += symp->sy_frag->fr_address + left;
1389 if (final_seg == expr_section || final_seg == undefined_section)
784b640d
AM		 1390 {
1391 if (seg_left == undefined_section
1392 || seg_right == undefined_section)
1393 final_seg = undefined_section;
1394 else if (seg_left == absolute_section)
1395 final_seg = seg_right;
1396 else
1397 final_seg = seg_left;
1398 }
49309057
ILT		 1399 resolved = (symbol_resolved_p (add_symbol)
1400 && symbol_resolved_p (op_symbol));
7c743825 1401 break;
252b5132
RH		 1402
1403 case O_register:
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
1950}
1951
252b5132 1952int
74937d39 1953S_IS_FUNCTION (symbolS *s)
252b5132 1954{
49309057
ILT		 1955 flagword flags;
1956
1957 if (LOCAL_SYMBOL_CHECK (s))
1958 return 0;
1959
1960 flags = s->bsym->flags;
252b5132
RH		 1961
1962 return (flags & BSF_FUNCTION) != 0;
1963}
1964
1965int
74937d39 1966S_IS_EXTERNAL (symbolS *s)
252b5132 1967{
49309057
ILT		 1968 flagword flags;
1969
1970 if (LOCAL_SYMBOL_CHECK (s))
1971 return 0;
1972
1973 flags = s->bsym->flags;
252b5132 1974
7c743825 1975 /* Sanity check. */
252b5132
RH		 1976 if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL))
1977 abort ();
1978
1979 return (flags & BSF_GLOBAL) != 0;
1980}
1981
1982int
74937d39 1983S_IS_WEAK (symbolS *s)
252b5132 1984{
49309057
ILT		 1985 if (LOCAL_SYMBOL_CHECK (s))
1986 return 0;
06e77878
AO		 1987 /* Conceptually, a weakrefr is weak if the referenced symbol is. We
1988 could probably handle a WEAKREFR as always weak though. E.g., if
1989 the referenced symbol has lost its weak status, there's no reason
1990 to keep handling the weakrefr as if it was weak. */
1991 if (S_IS_WEAKREFR (s))
1992 return S_IS_WEAK (s->sy_value.X_add_symbol);
252b5132
RH		 1993 return (s->bsym->flags & BSF_WEAK) != 0;
1994}
1995
06e77878
AO		 1996int
1997S_IS_WEAKREFR (symbolS *s)
1998{
1999 if (LOCAL_SYMBOL_CHECK (s))
2000 return 0;
2001 return s->sy_weakrefr != 0;
2002}
2003
2004int
2005S_IS_WEAKREFD (symbolS *s)
2006{
2007 if (LOCAL_SYMBOL_CHECK (s))
2008 return 0;
2009 return s->sy_weakrefd != 0;
2010}
2011
252b5132 2012int
74937d39 2013S_IS_COMMON (symbolS *s)
252b5132 2014{
49309057
ILT		 2015 if (LOCAL_SYMBOL_CHECK (s))
2016 return 0;
252b5132
RH		 2017 return bfd_is_com_section (s->bsym->section);
2018}
2019
2020int
74937d39 2021S_IS_DEFINED (symbolS *s)
252b5132 2022{
49309057
ILT		 2023 if (LOCAL_SYMBOL_CHECK (s))
2024 return ((struct local_symbol *) s)->lsy_section != undefined_section;
252b5132
RH		 2025 return s->bsym->section != undefined_section;
2026}
2027
a161fe53
AM		 2028
2029#ifndef EXTERN_FORCE_RELOC
2030#define EXTERN_FORCE_RELOC IS_ELF
2031#endif
2032
2033/* Return true for symbols that should not be reduced to section
2034 symbols or eliminated from expressions, because they may be
2035 overridden by the linker. */
2036int
74937d39 2037S_FORCE_RELOC (symbolS *s, int strict)
a161fe53
AM		 2038{
2039 if (LOCAL_SYMBOL_CHECK (s))
2040 return ((struct local_symbol *) s)->lsy_section == undefined_section;
2041
ae6063d4
AM		 2042 return ((strict
2043 && ((s->bsym->flags & BSF_WEAK) != 0
2044 || (EXTERN_FORCE_RELOC
2045 && (s->bsym->flags & BSF_GLOBAL) != 0)))
a161fe53
AM		 2046 || s->bsym->section == undefined_section
2047 || bfd_is_com_section (s->bsym->section));
2048}
2049
252b5132 2050int
74937d39 2051S_IS_DEBUG (symbolS *s)
252b5132 2052{
49309057
ILT		 2053 if (LOCAL_SYMBOL_CHECK (s))
2054 return 0;
252b5132
RH		 2055 if (s->bsym->flags & BSF_DEBUGGING)
2056 return 1;
2057 return 0;
2058}
2059
2060int
74937d39 2061S_IS_LOCAL (symbolS *s)
252b5132 2062{
49309057 2063 flagword flags;
252b5132
RH		 2064 const char *name;
2065
49309057
ILT		 2066 if (LOCAL_SYMBOL_CHECK (s))
2067 return 1;
2068
2069 flags = s->bsym->flags;
2070
7c743825 2071 /* Sanity check. */
252b5132
RH		 2072 if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL))
2073 abort ();
2074
2075 if (bfd_get_section (s->bsym) == reg_section)
2076 return 1;
2077
2078 if (flag_strip_local_absolute
bb82af9f
NC		 2079 /* Keep BSF_FILE symbols in order to allow debuggers to identify
2080 the source file even when the object file is stripped. */
2081 && (flags & (BSF_GLOBAL | BSF_FILE)) == 0
252b5132
RH		 2082 && bfd_get_section (s->bsym) == absolute_section)
2083 return 1;
2084
2085 name = S_GET_NAME (s);
2086 return (name != NULL
2087 && ! S_IS_DEBUG (s)
aa257fcd
NC		 2088 && (strchr (name, DOLLAR_LABEL_CHAR)
2089 || strchr (name, LOCAL_LABEL_CHAR)
252b5132
RH		 2090 || (! flag_keep_locals
2091 && (bfd_is_local_label (stdoutput, s->bsym)
2092 || (flag_mri
2093 && name[0] == '?'
2094 && name[1] == '?')))));
2095}
2096
252b5132 2097int
74937d39 2098S_IS_STABD (symbolS *s)
252b5132
RH		 2099{
2100 return S_GET_NAME (s) == 0;
2101}
2102
9497f5ac
NC		 2103int
2104S_IS_VOLATILE (const symbolS *s)
2105{
2106 if (LOCAL_SYMBOL_CHECK (s))
2107 return 0;
2108 return s->sy_volatile;
2109}
2110
2111int
2112S_IS_FORWARD_REF (const symbolS *s)
2113{
2114 if (LOCAL_SYMBOL_CHECK (s))
2115 return 0;
2116 return s->sy_forward_ref;
2117}
2118
9758f3fc 2119const char *
74937d39 2120S_GET_NAME (symbolS *s)
252b5132 2121{
49309057
ILT		 2122 if (LOCAL_SYMBOL_CHECK (s))
2123 return ((struct local_symbol *) s)->lsy_name;
252b5132
RH		 2124 return s->bsym->name;
2125}
2126
2127segT
74937d39 2128S_GET_SEGMENT (symbolS *s)
252b5132 2129{
49309057
ILT		 2130 if (LOCAL_SYMBOL_CHECK (s))
2131 return ((struct local_symbol *) s)->lsy_section;
252b5132
RH		 2132 return s->bsym->section;
2133}
2134
2135void
74937d39 2136S_SET_SEGMENT (symbolS *s, segT seg)
252b5132
RH		 2137{
2138 /* Don't reassign section symbols. The direct reason is to prevent seg
2139 faults assigning back to const global symbols such as *ABS*, but it
2140 shouldn't happen anyway. */
2141
49309057
ILT		 2142 if (LOCAL_SYMBOL_CHECK (s))
2143 {
2144 if (seg == reg_section)
2145 s = local_symbol_convert ((struct local_symbol *) s);
2146 else
2147 {
2148 ((struct local_symbol *) s)->lsy_section = seg;
2149 return;
2150 }
2151 }
2152
252b5132
RH		 2153 if (s->bsym->flags & BSF_SECTION_SYM)
2154 {
2155 if (s->bsym->section != seg)
7c743825 2156 abort ();
252b5132
RH		 2157 }
2158 else
2159 s->bsym->section = seg;
2160}
2161
2162void
74937d39 2163S_SET_EXTERNAL (symbolS *s)
252b5132 2164{
49309057
ILT		 2165 if (LOCAL_SYMBOL_CHECK (s))
2166 s = local_symbol_convert ((struct local_symbol *) s);
252b5132
RH		 2167 if ((s->bsym->flags & BSF_WEAK) != 0)
2168 {
2169 /* Let .weak override .global. */
2170 return;
2171 }
4d7c34bf
NC		 2172 if (s->bsym->flags & BSF_SECTION_SYM)
2173 {
2174 char * file;
2175 unsigned int line;
d1a6c242 2176
4d7c34bf
NC		 2177 /* Do not reassign section symbols. */
2178 as_where (& file, & line);
2179 as_warn_where (file, line,
0e389e77 2180 _("section symbols are already global"));
4d7c34bf
NC		 2181 return;
2182 }
252b5132 2183 s->bsym->flags |= BSF_GLOBAL;
7c743825 2184 s->bsym->flags &= ~(BSF_LOCAL | BSF_WEAK);
977cdf5a
NC		 2185
2186#ifdef USE_UNIQUE
2187 if (! an_external_name && S_GET_NAME(s)[0] != '.')
2188 an_external_name = S_GET_NAME (s);
2189#endif
252b5132
RH		 2190}
2191
2192void
74937d39 2193S_CLEAR_EXTERNAL (symbolS *s)
252b5132 2194{
49309057
ILT		 2195 if (LOCAL_SYMBOL_CHECK (s))
2196 return;
252b5132
RH		 2197 if ((s->bsym->flags & BSF_WEAK) != 0)
2198 {
2199 /* Let .weak override. */
2200 return;
2201 }
2202 s->bsym->flags |= BSF_LOCAL;
7c743825 2203 s->bsym->flags &= ~(BSF_GLOBAL | BSF_WEAK);
252b5132
RH		 2204}
2205
2206void
74937d39 2207S_SET_WEAK (symbolS *s)
252b5132 2208{
49309057
ILT		 2209 if (LOCAL_SYMBOL_CHECK (s))
2210 s = local_symbol_convert ((struct local_symbol *) s);
06e77878
AO		 2211#ifdef obj_set_weak_hook
2212 obj_set_weak_hook (s);
2213#endif
252b5132 2214 s->bsym->flags |= BSF_WEAK;
7c743825 2215 s->bsym->flags &= ~(BSF_GLOBAL | BSF_LOCAL);
252b5132
RH		 2216}
2217
06e77878
AO		 2218void
2219S_SET_WEAKREFR (symbolS *s)
2220{
2221 if (LOCAL_SYMBOL_CHECK (s))
2222 s = local_symbol_convert ((struct local_symbol *) s);
2223 s->sy_weakrefr = 1;
2224 /* If the alias was already used, make sure we mark the target as
2225 used as well, otherwise it might be dropped from the symbol
2226 table. This may have unintended side effects if the alias is
2227 later redirected to another symbol, such as keeping the unused
2228 previous target in the symbol table. Since it will be weak, it's
2229 not a big deal. */
2230 if (s->sy_used)
2231 symbol_mark_used (s->sy_value.X_add_symbol);
2232}
2233
2234void
2235S_CLEAR_WEAKREFR (symbolS *s)
2236{
2237 if (LOCAL_SYMBOL_CHECK (s))
2238 return;
2239 s->sy_weakrefr = 0;
2240}
2241
2242void
2243S_SET_WEAKREFD (symbolS *s)
2244{
2245 if (LOCAL_SYMBOL_CHECK (s))
2246 s = local_symbol_convert ((struct local_symbol *) s);
2247 s->sy_weakrefd = 1;
2248 S_SET_WEAK (s);
2249}
2250
2251void
2252S_CLEAR_WEAKREFD (symbolS *s)
2253{
2254 if (LOCAL_SYMBOL_CHECK (s))
2255 return;
2256 if (s->sy_weakrefd)
2257 {
2258 s->sy_weakrefd = 0;
2259 /* If a weakref target symbol is weak, then it was never
2260 referenced directly before, not even in a .global directive,
2261 so decay it to local. If it remains undefined, it will be
2262 later turned into a global, like any other undefined
2263 symbol. */
2264 if (s->bsym->flags & BSF_WEAK)
2265 {
2266#ifdef obj_clear_weak_hook
2267 obj_clear_weak_hook (s);
2268#endif
2269 s->bsym->flags &= ~BSF_WEAK;
2270 s->bsym->flags |= BSF_LOCAL;
2271 }
2272 }
2273}
2274
00f7efb6 2275void
74937d39 2276S_SET_THREAD_LOCAL (symbolS *s)
00f7efb6
JJ		 2277{
2278 if (LOCAL_SYMBOL_CHECK (s))
2279 s = local_symbol_convert ((struct local_symbol *) s);
2280 if (bfd_is_com_section (s->bsym->section)
2281 && (s->bsym->flags & BSF_THREAD_LOCAL) != 0)
2282 return;
2283 s->bsym->flags |= BSF_THREAD_LOCAL;
2284 if ((s->bsym->flags & BSF_FUNCTION) != 0)
2285 as_bad (_("Accessing function `%s' as thread-local object"),
2286 S_GET_NAME (s));
2287 else if (! bfd_is_und_section (s->bsym->section)
2288 && (s->bsym->section->flags & SEC_THREAD_LOCAL) == 0)
2289 as_bad (_("Accessing `%s' as thread-local object"),
2290 S_GET_NAME (s));
2291}
2292
252b5132 2293void
977cdf5a 2294S_SET_NAME (symbolS *s, const char *name)
252b5132 2295{
49309057
ILT		 2296 if (LOCAL_SYMBOL_CHECK (s))
2297 {
2298 ((struct local_symbol *) s)->lsy_name = name;
2299 return;
2300 }
252b5132
RH		 2301 s->bsym->name = name;
2302}
49309057 2303
9497f5ac
NC		 2304void
2305S_SET_VOLATILE (symbolS *s)
2306{
2307 if (LOCAL_SYMBOL_CHECK (s))
2308 s = local_symbol_convert ((struct local_symbol *) s);
2309 s->sy_volatile = 1;
2310}
2311
92757bc9
JB		 2312void
2313S_CLEAR_VOLATILE (symbolS *s)
2314{
2315 if (!LOCAL_SYMBOL_CHECK (s))
2316 s->sy_volatile = 0;
2317}
2318
9497f5ac
NC		 2319void
2320S_SET_FORWARD_REF (symbolS *s)
2321{
2322 if (LOCAL_SYMBOL_CHECK (s))
2323 s = local_symbol_convert ((struct local_symbol *) s);
2324 s->sy_forward_ref = 1;
2325}
2326
49309057
ILT		 2327/* Return the previous symbol in a chain. */
2328
2329symbolS *
74937d39 2330symbol_previous (symbolS *s)
49309057
ILT		 2331{
2332 if (LOCAL_SYMBOL_CHECK (s))
2333 abort ();
2334 return s->sy_previous;
2335}
2336
49309057
ILT		 2337/* Return the next symbol in a chain. */
2338
2339symbolS *
74937d39 2340symbol_next (symbolS *s)
49309057
ILT		 2341{
2342 if (LOCAL_SYMBOL_CHECK (s))
2343 abort ();
2344 return s->sy_next;
2345}
2346
2347/* Return a pointer to the value of a symbol as an expression. */
2348
2349expressionS *
74937d39 2350symbol_get_value_expression (symbolS *s)
49309057
ILT		 2351{
2352 if (LOCAL_SYMBOL_CHECK (s))
2353 s = local_symbol_convert ((struct local_symbol *) s);
2354 return &s->sy_value;
2355}
2356
2357/* Set the value of a symbol to an expression. */
2358
2359void
74937d39 2360symbol_set_value_expression (symbolS *s, const expressionS *exp)
49309057
ILT		 2361{
2362 if (LOCAL_SYMBOL_CHECK (s))
2363 s = local_symbol_convert ((struct local_symbol *) s);
2364 s->sy_value = *exp;
06e77878 2365 S_CLEAR_WEAKREFR (s);
49309057
ILT		 2366}
2367
be95a9c1
AM		 2368/* Return a pointer to the X_add_number component of a symbol. */
2369
514d955d 2370offsetT *
be95a9c1
AM		 2371symbol_X_add_number (symbolS *s)
2372{
be95a9c1 2373 if (LOCAL_SYMBOL_CHECK (s))
514d955d 2374 return (offsetT *) &((struct local_symbol *) s)->lsy_value;
be95a9c1 2375
514d955d 2376 return &s->sy_value.X_add_number;
be95a9c1
AM		 2377}
2378
b7d6ed97
RH		 2379/* Set the value of SYM to the current position in the current segment. */
2380
2381void
74937d39 2382symbol_set_value_now (symbolS *sym)
b7d6ed97
RH		 2383{
2384 S_SET_SEGMENT (sym, now_seg);
2385 S_SET_VALUE (sym, frag_now_fix ());
2386 symbol_set_frag (sym, frag_now);
2387}
2388
49309057
ILT		 2389/* Set the frag of a symbol. */
2390
2391void
74937d39 2392symbol_set_frag (symbolS *s, fragS *f)
49309057
ILT		 2393{
2394 if (LOCAL_SYMBOL_CHECK (s))
2395 {
2396 local_symbol_set_frag ((struct local_symbol *) s, f);
2397 return;
2398 }
2399 s->sy_frag = f;
06e77878 2400 S_CLEAR_WEAKREFR (s);
49309057
ILT		 2401}
2402
2403/* Return the frag of a symbol. */
2404
2405fragS *
74937d39 2406symbol_get_frag (symbolS *s)
49309057
ILT		 2407{
2408 if (LOCAL_SYMBOL_CHECK (s))
2409 return local_symbol_get_frag ((struct local_symbol *) s);
2410 return s->sy_frag;
2411}
2412
2413/* Mark a symbol as having been used. */
2414
2415void
74937d39 2416symbol_mark_used (symbolS *s)
49309057
ILT		 2417{
2418 if (LOCAL_SYMBOL_CHECK (s))
2419 return;
2420 s->sy_used = 1;
06e77878
AO		 2421 if (S_IS_WEAKREFR (s))
2422 symbol_mark_used (s->sy_value.X_add_symbol);
49309057
ILT		 2423}
2424
2425/* Clear the mark of whether a symbol has been used. */
2426
2427void
74937d39 2428symbol_clear_used (symbolS *s)
49309057
ILT		 2429{
2430 if (LOCAL_SYMBOL_CHECK (s))
2431 s = local_symbol_convert ((struct local_symbol *) s);
2432 s->sy_used = 0;
2433}
2434
2435/* Return whether a symbol has been used. */
2436
2437int
74937d39 2438symbol_used_p (symbolS *s)
49309057
ILT		 2439{
2440 if (LOCAL_SYMBOL_CHECK (s))
2441 return 1;
2442 return s->sy_used;
2443}
2444
2445/* Mark a symbol as having been used in a reloc. */
2446
2447void
74937d39 2448symbol_mark_used_in_reloc (symbolS *s)
49309057
ILT		 2449{
2450 if (LOCAL_SYMBOL_CHECK (s))
2451 s = local_symbol_convert ((struct local_symbol *) s);
2452 s->sy_used_in_reloc = 1;
2453}
2454
2455/* Clear the mark of whether a symbol has been used in a reloc. */
2456
2457void
74937d39 2458symbol_clear_used_in_reloc (symbolS *s)
49309057
ILT		 2459{
2460 if (LOCAL_SYMBOL_CHECK (s))
2461 return;
2462 s->sy_used_in_reloc = 0;
2463}
2464
2465/* Return whether a symbol has been used in a reloc. */
2466
2467int
74937d39 2468symbol_used_in_reloc_p (symbolS *s)
49309057
ILT		 2469{
2470 if (LOCAL_SYMBOL_CHECK (s))
2471 return 0;
2472 return s->sy_used_in_reloc;
2473}
2474
2475/* Mark a symbol as an MRI common symbol. */
2476
2477void
74937d39 2478symbol_mark_mri_common (symbolS *s)
49309057
ILT		 2479{
2480 if (LOCAL_SYMBOL_CHECK (s))
2481 s = local_symbol_convert ((struct local_symbol *) s);
2482 s->sy_mri_common = 1;
2483}
2484
2485/* Clear the mark of whether a symbol is an MRI common symbol. */
2486
2487void
74937d39 2488symbol_clear_mri_common (symbolS *s)
49309057
ILT		 2489{
2490 if (LOCAL_SYMBOL_CHECK (s))
2491 return;
2492 s->sy_mri_common = 0;
2493}
2494
2495/* Return whether a symbol is an MRI common symbol. */
2496
2497int
74937d39 2498symbol_mri_common_p (symbolS *s)
49309057
ILT		 2499{
2500 if (LOCAL_SYMBOL_CHECK (s))
2501 return 0;
2502 return s->sy_mri_common;
2503}
2504
2505/* Mark a symbol as having been written. */
2506
2507void
74937d39 2508symbol_mark_written (symbolS *s)
49309057
ILT		 2509{
2510 if (LOCAL_SYMBOL_CHECK (s))
2511 return;
2512 s->written = 1;
2513}
2514
2515/* Clear the mark of whether a symbol has been written. */
2516
2517void
74937d39 2518symbol_clear_written (symbolS *s)
49309057
ILT		 2519{
2520 if (LOCAL_SYMBOL_CHECK (s))
2521 return;
2522 s->written = 0;
2523}
2524
2525/* Return whether a symbol has been written. */
2526
2527int
74937d39 2528symbol_written_p (symbolS *s)
49309057
ILT		 2529{
2530 if (LOCAL_SYMBOL_CHECK (s))
2531 return 0;
2532 return s->written;
2533}
2534
2535/* Mark a symbol has having been resolved. */
2536
2537void
74937d39 2538symbol_mark_resolved (symbolS *s)
49309057
ILT		 2539{
2540 if (LOCAL_SYMBOL_CHECK (s))
2541 {
2542 local_symbol_mark_resolved ((struct local_symbol *) s);
2543 return;
2544 }
2545 s->sy_resolved = 1;
2546}
2547
2548/* Return whether a symbol has been resolved. */
2549
2550int
74937d39 2551symbol_resolved_p (symbolS *s)
49309057
ILT		 2552{
2553 if (LOCAL_SYMBOL_CHECK (s))
2554 return local_symbol_resolved_p ((struct local_symbol *) s);
2555 return s->sy_resolved;
2556}
2557
2558/* Return whether a symbol is a section symbol. */
2559
2560int
74937d39 2561symbol_section_p (symbolS *s ATTRIBUTE_UNUSED)
49309057
ILT		 2562{
2563 if (LOCAL_SYMBOL_CHECK (s))
2564 return 0;
49309057 2565 return (s->bsym->flags & BSF_SECTION_SYM) != 0;
49309057
ILT		 2566}
2567
2568/* Return whether a symbol is equated to another symbol. */
2569
2570int
74937d39 2571symbol_equated_p (symbolS *s)
49309057
ILT		 2572{
2573 if (LOCAL_SYMBOL_CHECK (s))
2574 return 0;
2575 return s->sy_value.X_op == O_symbol;
2576}
2577
e0890092
AM		 2578/* Return whether a symbol is equated to another symbol, and should be
2579 treated specially when writing out relocs. */
2580
2581int
74937d39 2582symbol_equated_reloc_p (symbolS *s)
e0890092
AM		 2583{
2584 if (LOCAL_SYMBOL_CHECK (s))
2585 return 0;
2586 /* X_op_symbol, normally not used for O_symbol, is set by
2587 resolve_symbol_value to flag expression syms that have been
2588 equated. */
2589 return (s->sy_value.X_op == O_symbol
7be1c489 2590#if defined (OBJ_COFF) && defined (TE_PE)
977cdf5a
NC		 2591 && ! S_IS_WEAK (s)
2592#endif
e0890092
AM		 2593 && ((s->sy_resolved && s->sy_value.X_op_symbol != NULL)
2594 || ! S_IS_DEFINED (s)
2595 || S_IS_COMMON (s)));
2596}
2597
49309057
ILT		 2598/* Return whether a symbol has a constant value. */
2599
2600int
74937d39 2601symbol_constant_p (symbolS *s)
49309057
ILT		 2602{
2603 if (LOCAL_SYMBOL_CHECK (s))
2604 return 1;
2605 return s->sy_value.X_op == O_constant;
2606}
2607
bdf128d6
JB		 2608/* Return whether a symbol was cloned and thus removed from the global
2609 symbol list. */
2610
2611int
2612symbol_shadow_p (symbolS *s)
2613{
2614 if (LOCAL_SYMBOL_CHECK (s))
2615 return 0;
2616 return s->sy_next == s;
2617}
2618
49309057
ILT		 2619/* Return the BFD symbol for a symbol. */
2620
2621asymbol *
74937d39 2622symbol_get_bfdsym (symbolS *s)
49309057
ILT		 2623{
2624 if (LOCAL_SYMBOL_CHECK (s))
2625 s = local_symbol_convert ((struct local_symbol *) s);
2626 return s->bsym;
2627}
2628
2629/* Set the BFD symbol for a symbol. */
2630
2631void
74937d39 2632symbol_set_bfdsym (symbolS *s, asymbol *bsym)
49309057
ILT		 2633{
2634 if (LOCAL_SYMBOL_CHECK (s))
2635 s = local_symbol_convert ((struct local_symbol *) s);
22fe14ad
NC		 2636 /* Usually, it is harmless to reset a symbol to a BFD section
2637 symbol. For example, obj_elf_change_section sets the BFD symbol
2638 of an old symbol with the newly created section symbol. But when
2639 we have multiple sections with the same name, the newly created
2640 section may have the same name as an old section. We check if the
2641 old symbol has been already marked as a section symbol before
2642 resetting it. */
2643 if ((s->bsym->flags & BSF_SECTION_SYM) == 0)
2644 s->bsym = bsym;
2645 /* else XXX - What do we do now ? */
49309057
ILT		 2646}
2647
49309057
ILT		 2648#ifdef OBJ_SYMFIELD_TYPE
2649
2650/* Get a pointer to the object format information for a symbol. */
2651
2652OBJ_SYMFIELD_TYPE *
74937d39 2653symbol_get_obj (symbolS *s)
49309057
ILT		 2654{
2655 if (LOCAL_SYMBOL_CHECK (s))
2656 s = local_symbol_convert ((struct local_symbol *) s);
2657 return &s->sy_obj;
2658}
2659
2660/* Set the object format information for a symbol. */
2661
2662void
74937d39 2663symbol_set_obj (symbolS *s, OBJ_SYMFIELD_TYPE *o)
49309057
ILT		 2664{
2665 if (LOCAL_SYMBOL_CHECK (s))
2666 s = local_symbol_convert ((struct local_symbol *) s);
2667 s->sy_obj = *o;
2668}
2669
2670#endif /* OBJ_SYMFIELD_TYPE */
2671
2672#ifdef TC_SYMFIELD_TYPE
2673
2674/* Get a pointer to the processor information for a symbol. */
2675
2676TC_SYMFIELD_TYPE *
74937d39 2677symbol_get_tc (symbolS *s)
49309057
ILT		 2678{
2679 if (LOCAL_SYMBOL_CHECK (s))
2680 s = local_symbol_convert ((struct local_symbol *) s);
2681 return &s->sy_tc;
2682}
2683
2684/* Set the processor information for a symbol. */
2685
2686void
74937d39 2687symbol_set_tc (symbolS *s, TC_SYMFIELD_TYPE *o)
49309057
ILT		 2688{
2689 if (LOCAL_SYMBOL_CHECK (s))
2690 s = local_symbol_convert ((struct local_symbol *) s);
2691 s->sy_tc = *o;
2692}
2693
2694#endif /* TC_SYMFIELD_TYPE */
2695
252b5132 2696void
74937d39 2697symbol_begin (void)
252b5132
RH		 2698{
2699 symbol_lastP = NULL;
7c743825 2700 symbol_rootP = NULL; /* In case we have 0 symbols (!!) */
252b5132 2701 sy_hash = hash_new ();
49309057 2702 local_hash = hash_new ();
252b5132
RH		 2703
2704 memset ((char *) (&abs_symbol), '\0', sizeof (abs_symbol));
252b5132
RH		 2705#if defined (EMIT_SECTION_SYMBOLS) || !defined (RELOC_REQUIRES_SYMBOL)
2706 abs_symbol.bsym = bfd_abs_section.symbol;
252b5132
RH		 2707#endif
2708 abs_symbol.sy_value.X_op = O_constant;
2709 abs_symbol.sy_frag = &zero_address_frag;
2710
2711 if (LOCAL_LABELS_FB)
2712 fb_label_init ();
2713}
252b5132
RH		 2714\f
2715int indent_level;
2716
2717/* Maximum indent level.
2718 Available for modification inside a gdb session. */
87c245cc 2719static int max_indent_level = 8;
252b5132 2720
252b5132 2721void
74937d39 2722print_symbol_value_1 (FILE *file, symbolS *sym)
252b5132
RH		 2723{
2724 const char *name = S_GET_NAME (sym);
2725 if (!name || !name[0])
2726 name = "(unnamed)";
2727 fprintf (file, "sym %lx %s", (unsigned long) sym, name);
49309057
ILT		 2728
2729 if (LOCAL_SYMBOL_CHECK (sym))
2730 {
2731 struct local_symbol *locsym = (struct local_symbol *) sym;
2732 if (local_symbol_get_frag (locsym) != &zero_address_frag
2733 && local_symbol_get_frag (locsym) != NULL)
2734 fprintf (file, " frag %lx", (long) local_symbol_get_frag (locsym));
2735 if (local_symbol_resolved_p (locsym))
2736 fprintf (file, " resolved");
2737 fprintf (file, " local");
2738 }
2739 else
2740 {
2741 if (sym->sy_frag != &zero_address_frag)
2742 fprintf (file, " frag %lx", (long) sym->sy_frag);
2743 if (sym->written)
2744 fprintf (file, " written");
2745 if (sym->sy_resolved)
2746 fprintf (file, " resolved");
2747 else if (sym->sy_resolving)
2748 fprintf (file, " resolving");
2749 if (sym->sy_used_in_reloc)
2750 fprintf (file, " used-in-reloc");
2751 if (sym->sy_used)
2752 fprintf (file, " used");
2753 if (S_IS_LOCAL (sym))
2754 fprintf (file, " local");
e97b3f28 2755 if (S_IS_EXTERNAL (sym))
49309057 2756 fprintf (file, " extern");
06e77878
AO		 2757 if (S_IS_WEAK (sym))
2758 fprintf (file, " weak");
49309057
ILT		 2759 if (S_IS_DEBUG (sym))
2760 fprintf (file, " debug");
2761 if (S_IS_DEFINED (sym))
2762 fprintf (file, " defined");
2763 }
06e77878
AO		 2764 if (S_IS_WEAKREFR (sym))
2765 fprintf (file, " weakrefr");
2766 if (S_IS_WEAKREFD (sym))
2767 fprintf (file, " weakrefd");
252b5132 2768 fprintf (file, " %s", segment_name (S_GET_SEGMENT (sym)));
49309057 2769 if (symbol_resolved_p (sym))
252b5132
RH		 2770 {
2771 segT s = S_GET_SEGMENT (sym);
2772
2773 if (s != undefined_section
411863a4 2774 && s != expr_section)
252b5132
RH		 2775 fprintf (file, " %lx", (long) S_GET_VALUE (sym));
2776 }
2777 else if (indent_level < max_indent_level
2778 && S_GET_SEGMENT (sym) != undefined_section)
2779 {
2780 indent_level++;
2781 fprintf (file, "\n%*s<", indent_level * 4, "");
49309057
ILT		 2782 if (LOCAL_SYMBOL_CHECK (sym))
2783 fprintf (file, "constant %lx",
bd780143 2784 (long) ((struct local_symbol *) sym)->lsy_value);
49309057
ILT		 2785 else
2786 print_expr_1 (file, &sym->sy_value);
252b5132
RH		 2787 fprintf (file, ">");
2788 indent_level--;
2789 }
2790 fflush (file);
2791}
2792
2793void
74937d39 2794print_symbol_value (symbolS *sym)
252b5132
RH		 2795{
2796 indent_level = 0;
2797 print_symbol_value_1 (stderr, sym);
2798 fprintf (stderr, "\n");
2799}
2800
2801static void
74937d39 2802print_binary (FILE *file, const char *name, expressionS *exp)
252b5132
RH		 2803{
2804 indent_level++;
2805 fprintf (file, "%s\n%*s<", name, indent_level * 4, "");
2806 print_symbol_value_1 (file, exp->X_add_symbol);
2807 fprintf (file, ">\n%*s<", indent_level * 4, "");
2808 print_symbol_value_1 (file, exp->X_op_symbol);
2809 fprintf (file, ">");
2810 indent_level--;
2811}
2812
2813void
74937d39 2814print_expr_1 (FILE *file, expressionS *exp)
252b5132
RH		 2815{
2816 fprintf (file, "expr %lx ", (long) exp);
2817 switch (exp->X_op)
2818 {
2819 case O_illegal:
2820 fprintf (file, "illegal");
2821 break;
2822 case O_absent:
2823 fprintf (file, "absent");
2824 break;
2825 case O_constant:
2826 fprintf (file, "constant %lx", (long) exp->X_add_number);
2827 break;
2828 case O_symbol:
2829 indent_level++;
2830 fprintf (file, "symbol\n%*s<", indent_level * 4, "");
2831 print_symbol_value_1 (file, exp->X_add_symbol);
2832 fprintf (file, ">");
2833 maybe_print_addnum:
2834 if (exp->X_add_number)
2835 fprintf (file, "\n%*s%lx", indent_level * 4, "",
2836 (long) exp->X_add_number);
2837 indent_level--;
2838 break;
2839 case O_register:
2840 fprintf (file, "register #%d", (int) exp->X_add_number);
2841 break;
2842 case O_big:
2843 fprintf (file, "big");
2844 break;
2845 case O_uminus:
2846 fprintf (file, "uminus -<");
2847 indent_level++;
2848 print_symbol_value_1 (file, exp->X_add_symbol);
2849 fprintf (file, ">");
2850 goto maybe_print_addnum;
2851 case O_bit_not:
2852 fprintf (file, "bit_not");
2853 break;
2854 case O_multiply:
2855 print_binary (file, "multiply", exp);
2856 break;
2857 case O_divide:
2858 print_binary (file, "divide", exp);
2859 break;
2860 case O_modulus:
2861 print_binary (file, "modulus", exp);
2862 break;
2863 case O_left_shift:
2864 print_binary (file, "lshift", exp);
2865 break;
2866 case O_right_shift:
2867 print_binary (file, "rshift", exp);
2868 break;
2869 case O_bit_inclusive_or:
2870 print_binary (file, "bit_ior", exp);
2871 break;
2872 case O_bit_exclusive_or:
2873 print_binary (file, "bit_xor", exp);
2874 break;
2875 case O_bit_and:
2876 print_binary (file, "bit_and", exp);
2877 break;
2878 case O_eq:
2879 print_binary (file, "eq", exp);
2880 break;
2881 case O_ne:
2882 print_binary (file, "ne", exp);
2883 break;
2884 case O_lt:
2885 print_binary (file, "lt", exp);
2886 break;
2887 case O_le:
2888 print_binary (file, "le", exp);
2889 break;
2890 case O_ge:
2891 print_binary (file, "ge", exp);
2892 break;
2893 case O_gt:
2894 print_binary (file, "gt", exp);
2895 break;
2896 case O_logical_and:
2897 print_binary (file, "logical_and", exp);
2898 break;
2899 case O_logical_or:
2900 print_binary (file, "logical_or", exp);
2901 break;
2902 case O_add:
2903 indent_level++;
2904 fprintf (file, "add\n%*s<", indent_level * 4, "");
2905 print_symbol_value_1 (file, exp->X_add_symbol);
2906 fprintf (file, ">\n%*s<", indent_level * 4, "");
2907 print_symbol_value_1 (file, exp->X_op_symbol);
2908 fprintf (file, ">");
2909 goto maybe_print_addnum;
2910 case O_subtract:
2911 indent_level++;
2912 fprintf (file, "subtract\n%*s<", indent_level * 4, "");
2913 print_symbol_value_1 (file, exp->X_add_symbol);
2914 fprintf (file, ">\n%*s<", indent_level * 4, "");
2915 print_symbol_value_1 (file, exp->X_op_symbol);
2916 fprintf (file, ">");
2917 goto maybe_print_addnum;
2918 default:
2919 fprintf (file, "{unknown opcode %d}", (int) exp->X_op);
2920 break;
2921 }
2922 fflush (stdout);
2923}
2924
2925void
74937d39 2926print_expr (expressionS *exp)
252b5132
RH		 2927{
2928 print_expr_1 (stderr, exp);
2929 fprintf (stderr, "\n");
2930}
2931
2932void
74937d39 2933symbol_print_statistics (FILE *file)
252b5132
RH		 2934{
2935 hash_print_statistics (file, "symbol table", sy_hash);
49309057
ILT		 2936 hash_print_statistics (file, "mini local symbol table", local_hash);
2937 fprintf (file, "%lu mini local symbols created, %lu converted\n",
2938 local_symbol_count, local_symbol_conversion_count);
252b5132 2939}
280d71bf
DB		 2940
2941#ifdef OBJ_COMPLEX_RELC
2942
2943/* Convert given symbol to a new complex-relocation symbol name. This
6f12865c 2944 may be a recursive function, since it might be called for non-leaf
280d71bf 2945 nodes (plain symbols) in the expression tree. The caller owns the
6f12865c
AM		 2946 returning string, so should free it eventually. Errors are
2947 indicated via as_bad and a NULL return value. The given symbol
280d71bf
DB		 2948 is marked with sy_used_in_reloc. */
2949
2950char *
2951symbol_relc_make_sym (symbolS * sym)
2952{
2953 char * terminal = NULL;
2954 const char * sname;
2955 char typetag;
2956 int sname_len;
2957
2958 assert (sym != NULL);
2959
2960 /* Recurse to symbol_relc_make_expr if this symbol
2961 is defined as an expression or a plain value. */
2962 if ( S_GET_SEGMENT (sym) == expr_section
2963 || S_GET_SEGMENT (sym) == absolute_section)
2964 return symbol_relc_make_expr (& sym->sy_value);
2965
2966 /* This may be a "fake symbol" L0\001, referring to ".".
2967 Write out a special null symbol to refer to this position. */
2968 if (! strcmp (S_GET_NAME (sym), FAKE_LABEL_NAME))
2969 return xstrdup (".");
2970
2971 /* We hope this is a plain leaf symbol. Construct the encoding
2972 as {S,s}II...:CCCCCCC....
2973 where 'S'/'s' means section symbol / plain symbol
2974 III is decimal for the symbol name length
2975 CCC is the symbol name itself. */
2976 symbol_mark_used_in_reloc (sym);
2977
2978 sname = S_GET_NAME (sym);
2979 sname_len = strlen (sname);
2980 typetag = symbol_section_p (sym) ? 'S' : 's';
2981
2982 terminal = xmalloc (1 /* S or s */
2983 + 8 /* sname_len in decimal */
2984 + 1 /* _ spacer */
2985 + sname_len /* name itself */
2986 + 1 /* \0 */ );
2987
2988 sprintf (terminal, "%c%d:%s", typetag, sname_len, sname);
2989 return terminal;
2990}
2991
2992/* Convert given value to a new complex-relocation symbol name. This
2993 is a non-recursive function, since it is be called for leaf nodes
2994 (plain values) in the expression tree. The caller owns the
2995 returning string, so should free() it eventually. No errors. */
2996
2997char *
2998symbol_relc_make_value (offsetT val)
2999{
3000 char * terminal = xmalloc (28); /* Enough for long long. */
3001
3002 terminal[0] = '#';
3003 sprintf_vma (& terminal[1], val);
3004 return terminal;
3005}
3006
3007/* Convert given expression to a new complex-relocation symbol name.
3008 This is a recursive function, since it traverses the entire given
3009 expression tree. The caller owns the returning string, so should
3010 free() it eventually. Errors are indicated via as_bad() and a NULL
3011 return value. */
3012
3013char *
3014symbol_relc_make_expr (expressionS * exp)
3015{
3016 char * opstr = NULL; /* Operator prefix string. */
3017 int arity = 0; /* Arity of this operator. */
3018 char * operands[3]; /* Up to three operands. */
3019 char * concat_string = NULL;
3020
3021 operands[0] = operands[1] = operands[2] = NULL;
3022
3023 assert (exp != NULL);
3024
3025 /* Match known operators -> fill in opstr, arity, operands[] and fall
3026 through to construct subexpression fragments; may instead return
3027 string directly for leaf nodes. */
3028
3029 /* See expr.h for the meaning of all these enums. Many operators
3030 have an unnatural arity (X_add_number implicitly added). The
3031 conversion logic expands them to explicit "+" subexpressions. */
3032
3033 switch (exp->X_op)
3034 {
3035 default:
3036 as_bad ("Unknown expression operator (enum %d)", exp->X_op);
3037 break;
3038
3039 /* Leaf nodes. */
3040 case O_constant:
3041 return symbol_relc_make_value (exp->X_add_number);
3042
3043 case O_symbol:
3044 if (exp->X_add_number)
3045 {
3046 arity = 2;
3047 opstr = "+";
3048 operands[0] = symbol_relc_make_sym (exp->X_add_symbol);
3049 operands[1] = symbol_relc_make_value (exp->X_add_number);
3050 break;
3051 }
3052 else
3053 return symbol_relc_make_sym (exp->X_add_symbol);
3054
3055 /* Helper macros for nesting nodes. */
3056
3057#define HANDLE_XADD_OPT1(str_) \
3058 if (exp->X_add_number) \
3059 { \
3060 arity = 2; \
3061 opstr = "+:" str_; \
3062 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3063 operands[1] = symbol_relc_make_value (exp->X_add_number); \
3064 break; \
3065 } \
3066 else \
3067 { \
3068 arity = 1; \
3069 opstr = str_; \
3070 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3071 } \
3072 break
3073
3074#define HANDLE_XADD_OPT2(str_) \
3075 if (exp->X_add_number) \
3076 { \
3077 arity = 3; \
3078 opstr = "+:" str_; \
3079 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3080 operands[1] = symbol_relc_make_sym (exp->X_op_symbol); \
3081 operands[2] = symbol_relc_make_value (exp->X_add_number); \
3082 } \
3083 else \
3084 { \
3085 arity = 2; \
3086 opstr = str_; \
3087 operands[0] = symbol_relc_make_sym (exp->X_add_symbol); \
3088 operands[1] = symbol_relc_make_sym (exp->X_op_symbol); \
3089 } \
3090 break
3091
3092 /* Nesting nodes. */
3093
3094 case O_uminus: HANDLE_XADD_OPT1 ("0-");
3095 case O_bit_not: HANDLE_XADD_OPT1 ("~");
3096 case O_logical_not: HANDLE_XADD_OPT1 ("!");
3097 case O_multiply: HANDLE_XADD_OPT2 ("*");
3098 case O_divide: HANDLE_XADD_OPT2 ("/");
3099 case O_modulus: HANDLE_XADD_OPT2 ("%");
3100 case O_left_shift: HANDLE_XADD_OPT2 ("<<");
3101 case O_right_shift: HANDLE_XADD_OPT2 (">>");
3102 case O_bit_inclusive_or: HANDLE_XADD_OPT2 ("|");
3103 case O_bit_exclusive_or: HANDLE_XADD_OPT2 ("^");
3104 case O_bit_and: HANDLE_XADD_OPT2 ("&");
3105 case O_add: HANDLE_XADD_OPT2 ("+");
3106 case O_subtract: HANDLE_XADD_OPT2 ("-");
3107 case O_eq: HANDLE_XADD_OPT2 ("==");
3108 case O_ne: HANDLE_XADD_OPT2 ("!=");
3109 case O_lt: HANDLE_XADD_OPT2 ("<");
3110 case O_le: HANDLE_XADD_OPT2 ("<=");
3111 case O_ge: HANDLE_XADD_OPT2 (">=");
3112 case O_gt: HANDLE_XADD_OPT2 (">");
3113 case O_logical_and: HANDLE_XADD_OPT2 ("&&");
3114 case O_logical_or: HANDLE_XADD_OPT2 ("||");
3115 }
3116
3117 /* Validate & reject early. */
3118 if (arity >= 1 && ((operands[0] == NULL) || (strlen (operands[0]) == 0)))
3119 opstr = NULL;
3120 if (arity >= 2 && ((operands[1] == NULL) || (strlen (operands[1]) == 0)))
3121 opstr = NULL;
3122 if (arity >= 3 && ((operands[2] == NULL) || (strlen (operands[2]) == 0)))
3123 opstr = NULL;
3124
3125 if (opstr == NULL)
3126 concat_string = NULL;
3127 else
3128 {
3129 /* Allocate new string; include inter-operand padding gaps etc. */
3130 concat_string = xmalloc (strlen (opstr)
3131 + 1
3132 + (arity >= 1 ? (strlen (operands[0]) + 1 ) : 0)
3133 + (arity >= 2 ? (strlen (operands[1]) + 1 ) : 0)
3134 + (arity >= 3 ? (strlen (operands[2]) + 0 ) : 0)
3135 + 1);
3136 assert (concat_string != NULL);
3137
3138 /* Format the thing. */
3139 sprintf (concat_string,
3140 (arity == 0 ? "%s" :
3141 arity == 1 ? "%s:%s" :
3142 arity == 2 ? "%s:%s:%s" :
3143 /* arity == 3 */ "%s:%s:%s:%s"),
3144 opstr, operands[0], operands[1], operands[2]);
3145 }
3146
3147 /* Free operand strings (not opstr). */
3148 if (arity >= 1) xfree (operands[0]);
3149 if (arity >= 2) xfree (operands[1]);
3150 if (arity >= 3) xfree (operands[2]);
3151
3152 return concat_string;
3153}
3154
3155#endif
GDB Binutils - Deliverables
This page took 0.47414 seconds and 4 git commands to generate.