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