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