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