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