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