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