symbols.c revision 60484
1/* symbols.c -symbol table- 2 Copyright (C) 1987, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000 3 Free Software Foundation, Inc. 4 5 This file is part of GAS, the GNU Assembler. 6 7 GAS is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 2, or (at your option) 10 any later version. 11 12 GAS is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with GAS; see the file COPYING. If not, write to the Free 19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA 20 02111-1307, USA. */ 21 22/* #define DEBUG_SYMS / * to debug symbol list maintenance */ 23 24#include <ctype.h> 25 26#include "as.h" 27 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 58struct obstack notes; 59 60static void fb_label_init PARAMS ((void)); 61static long dollar_label_instance PARAMS ((long)); 62static long fb_label_instance PARAMS ((long)); 63 64static void print_binary PARAMS ((FILE *, const char *, expressionS *)); 65 66/* symbol_new() 67 68 Return a pointer to a new symbol. Die if we can't make a new 69 symbol. Fill in the symbol's values. Add symbol to end of symbol 70 chain. 71 72 This function should be called in the general case of creating a 73 symbol. However, if the output file symbol table has already been 74 set, and you are certain that this symbol won't be wanted in the 75 output file, you can call symbol_create. */ 76 77symbolS * 78symbol_new (name, segment, valu, frag) 79 const char *name; 80 segT segment; 81 valueT valu; 82 fragS *frag; 83{ 84 symbolS *symbolP = symbol_create (name, segment, valu, frag); 85 86 /* 87 * Link to end of symbol chain. 88 */ 89#ifdef BFD_ASSEMBLER 90 { 91 extern int symbol_table_frozen; 92 if (symbol_table_frozen) 93 abort (); 94 } 95#endif 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 (name) 106 const char *name; 107{ 108 unsigned int name_length; 109 char *ret; 110 111 name_length = strlen (name) + 1; /* +1 for \0 */ 112 obstack_grow (¬es, name, name_length); 113 ret = obstack_finish (¬es); 114 115#ifdef STRIP_UNDERSCORE 116 if (ret[0] == '_') 117 ++ret; 118#endif 119 120#ifdef tc_canonicalize_symbol_name 121 ret = tc_canonicalize_symbol_name (ret); 122#endif 123 124 if (! symbols_case_sensitive) 125 { 126 unsigned char *s; 127 128 for (s = (unsigned char *) ret; *s != '\0'; s++) 129 if (islower (*s)) 130 *s = toupper (*s); 131 } 132 133 return ret; 134} 135 136symbolS * 137symbol_create (name, segment, valu, frag) 138 const char *name; /* It is copied, the caller can destroy/modify */ 139 segT segment; /* Segment identifier (SEG_<something>) */ 140 valueT valu; /* Symbol value */ 141 fragS *frag; /* Associated fragment */ 142{ 143 char *preserved_copy_of_name; 144 symbolS *symbolP; 145 146 preserved_copy_of_name = save_symbol_name (name); 147 148 symbolP = (symbolS *) obstack_alloc (¬es, sizeof (symbolS)); 149 150 /* symbol must be born in some fixed state. This seems as good as any. */ 151 memset (symbolP, 0, sizeof (symbolS)); 152 153#ifdef BFD_ASSEMBLER 154 symbolP->bsym = bfd_make_empty_symbol (stdoutput); 155 if (symbolP->bsym == NULL) 156 as_perror ("%s", "bfd_make_empty_symbol"); 157 symbolP->bsym->udata.p = (PTR) symbolP; 158#endif 159 S_SET_NAME (symbolP, preserved_copy_of_name); 160 161 S_SET_SEGMENT (symbolP, segment); 162 S_SET_VALUE (symbolP, valu); 163 symbol_clear_list_pointers (symbolP); 164 165 symbolP->sy_frag = frag; 166#ifndef BFD_ASSEMBLER 167 symbolP->sy_number = ~0; 168 symbolP->sy_name_offset = (unsigned int) ~0; 169#endif 170 171 obj_symbol_new_hook (symbolP); 172 173#ifdef tc_symbol_new_hook 174 tc_symbol_new_hook (symbolP); 175#endif 176 177 return symbolP; 178} 179 180#ifdef BFD_ASSEMBLER 181 182/* Local symbol support. If we can get away with it, we keep only a 183 small amount of information for local symbols. */ 184 185static struct local_symbol *local_symbol_make PARAMS ((const char *, segT, 186 valueT, fragS *)); 187static symbolS *local_symbol_convert PARAMS ((struct local_symbol *)); 188 189/* Used for statistics. */ 190 191static unsigned long local_symbol_count; 192static unsigned long local_symbol_conversion_count; 193 194/* This macro is called with a symbol argument passed by reference. 195 It returns whether this is a local symbol. If necessary, it 196 changes its argument to the real symbol. */ 197 198#define LOCAL_SYMBOL_CHECK(s) \ 199 (s->bsym == NULL \ 200 ? (local_symbol_converted_p ((struct local_symbol *) s) \ 201 ? (s = local_symbol_get_real_symbol ((struct local_symbol *) s), \ 202 0) \ 203 : 1) \ 204 : 0) 205 206/* Create a local symbol and insert it into the local hash table. */ 207 208static struct local_symbol * 209local_symbol_make (name, section, offset, frag) 210 const char *name; 211 segT section; 212 valueT offset; 213 fragS *frag; 214{ 215 char *name_copy; 216 struct local_symbol *ret; 217 218 ++local_symbol_count; 219 220 name_copy = save_symbol_name (name); 221 222 ret = (struct local_symbol *) obstack_alloc (¬es, sizeof *ret); 223 ret->lsy_marker = NULL; 224 ret->lsy_name = name_copy; 225 ret->lsy_section = section; 226 local_symbol_set_frag (ret, frag); 227 ret->lsy_offset = offset; 228 229 hash_jam (local_hash, name_copy, (PTR) ret); 230 231 return ret; 232} 233 234/* Convert a local symbol into a real symbol. Note that we do not 235 reclaim the space used by the local symbol. */ 236 237static symbolS * 238local_symbol_convert (locsym) 239 struct local_symbol *locsym; 240{ 241 symbolS *ret; 242 243 assert (locsym->lsy_marker == NULL); 244 if (local_symbol_converted_p (locsym)) 245 return local_symbol_get_real_symbol (locsym); 246 247 ++local_symbol_conversion_count; 248 249 ret = symbol_new (locsym->lsy_name, locsym->lsy_section, locsym->lsy_offset, 250 local_symbol_get_frag (locsym)); 251 252 if (local_symbol_resolved_p (locsym)) 253 ret->sy_resolved = 1; 254 255 /* Local symbols are always either defined or used. */ 256 ret->sy_used = 1; 257 258 symbol_table_insert (ret); 259 260 local_symbol_mark_converted (locsym); 261 local_symbol_set_real_symbol (locsym, ret); 262 263 hash_jam (local_hash, locsym->lsy_name, NULL); 264 265 return ret; 266} 267 268#else /* ! BFD_ASSEMBLER */ 269 270#define LOCAL_SYMBOL_CHECK(s) 0 271#define local_symbol_convert(s) ((symbolS *) s) 272 273#endif /* ! BFD_ASSEMBLER */ 274 275 276/* 277 * colon() 278 * 279 * We have just seen "<name>:". 280 * Creates a struct symbol unless it already exists. 281 * 282 * Gripes if we are redefining a symbol incompatibly (and ignores it). 283 * 284 */ 285symbolS * 286colon (sym_name) /* just seen "x:" - rattle symbols & frags */ 287 const char *sym_name; /* symbol name, as a cannonical string */ 288 /* We copy this string: OK to alter later. */ 289{ 290 register symbolS *symbolP; /* symbol we are working with */ 291 292 /* Sun local labels go out of scope whenever a non-local symbol is 293 defined. */ 294 if (LOCAL_LABELS_DOLLAR) 295 { 296 int local; 297 298#ifdef BFD_ASSEMBLER 299 local = bfd_is_local_label_name (stdoutput, sym_name); 300#else 301 local = LOCAL_LABEL (sym_name); 302#endif 303 304 if (! local) 305 dollar_label_clear (); 306 } 307 308#ifndef WORKING_DOT_WORD 309 if (new_broken_words) 310 { 311 struct broken_word *a; 312 int possible_bytes; 313 fragS *frag_tmp; 314 char *frag_opcode; 315 316 extern const int md_short_jump_size; 317 extern const int md_long_jump_size; 318 possible_bytes = (md_short_jump_size 319 + new_broken_words * md_long_jump_size); 320 321 frag_tmp = frag_now; 322 frag_opcode = frag_var (rs_broken_word, 323 possible_bytes, 324 possible_bytes, 325 (relax_substateT) 0, 326 (symbolS *) broken_words, 327 (offsetT) 0, 328 NULL); 329 330 /* We want to store the pointer to where to insert the jump table in the 331 fr_opcode of the rs_broken_word frag. This requires a little 332 hackery. */ 333 while (frag_tmp 334 && (frag_tmp->fr_type != rs_broken_word 335 || frag_tmp->fr_opcode)) 336 frag_tmp = frag_tmp->fr_next; 337 know (frag_tmp); 338 frag_tmp->fr_opcode = frag_opcode; 339 new_broken_words = 0; 340 341 for (a = broken_words; a && a->dispfrag == 0; a = a->next_broken_word) 342 a->dispfrag = frag_tmp; 343 } 344#endif /* WORKING_DOT_WORD */ 345 346 if ((symbolP = symbol_find (sym_name)) != 0) 347 { 348#ifdef RESOLVE_SYMBOL_REDEFINITION 349 if (RESOLVE_SYMBOL_REDEFINITION (symbolP)) 350 return symbolP; 351#endif 352 /* 353 * Now check for undefined symbols 354 */ 355 if (LOCAL_SYMBOL_CHECK (symbolP)) 356 { 357#ifdef BFD_ASSEMBLER 358 struct local_symbol *locsym = (struct local_symbol *) symbolP; 359 360 if (locsym->lsy_section != undefined_section 361 && (local_symbol_get_frag (locsym) != frag_now 362 || locsym->lsy_section != now_seg 363 || locsym->lsy_offset != frag_now_fix ())) 364 { 365 as_bad (_("Symbol %s already defined."), sym_name); 366 return symbolP; 367 } 368 369 locsym->lsy_section = now_seg; 370 local_symbol_set_frag (locsym, frag_now); 371 locsym->lsy_offset = frag_now_fix (); 372#endif 373 } 374 else if (!S_IS_DEFINED (symbolP) || S_IS_COMMON (symbolP)) 375 { 376 if (S_GET_VALUE (symbolP) == 0) 377 { 378 symbolP->sy_frag = frag_now; 379#ifdef OBJ_VMS 380 S_SET_OTHER(symbolP, const_flag); 381#endif 382 S_SET_VALUE (symbolP, (valueT) frag_now_fix ()); 383 S_SET_SEGMENT (symbolP, now_seg); 384#ifdef N_UNDF 385 know (N_UNDF == 0); 386#endif /* if we have one, it better be zero. */ 387 388 } 389 else 390 { 391 /* 392 * There are still several cases to check: 393 * A .comm/.lcomm symbol being redefined as 394 * initialized data is OK 395 * A .comm/.lcomm symbol being redefined with 396 * a larger size is also OK 397 * 398 * This only used to be allowed on VMS gas, but Sun cc 399 * on the sparc also depends on it. 400 */ 401 402 if (((!S_IS_DEBUG (symbolP) 403 && (!S_IS_DEFINED (symbolP) || S_IS_COMMON (symbolP)) 404 && S_IS_EXTERNAL (symbolP)) 405 || S_GET_SEGMENT (symbolP) == bss_section) 406 && (now_seg == data_section 407 || now_seg == S_GET_SEGMENT (symbolP))) 408 { 409 /* 410 * Select which of the 2 cases this is 411 */ 412 if (now_seg != data_section) 413 { 414 /* 415 * New .comm for prev .comm symbol. 416 * If the new size is larger we just 417 * change its value. If the new size 418 * is smaller, we ignore this symbol 419 */ 420 if (S_GET_VALUE (symbolP) 421 < ((unsigned) frag_now_fix ())) 422 { 423 S_SET_VALUE (symbolP, (valueT) frag_now_fix ()); 424 } 425 } 426 else 427 { 428 /* It is a .comm/.lcomm being converted to initialized 429 data. */ 430 symbolP->sy_frag = frag_now; 431#ifdef OBJ_VMS 432 S_SET_OTHER(symbolP, const_flag); 433#endif 434 S_SET_VALUE (symbolP, (valueT) frag_now_fix ()); 435 S_SET_SEGMENT (symbolP, now_seg); /* keep N_EXT bit */ 436 } 437 } 438 else 439 { 440#if (!defined (OBJ_AOUT) && !defined (OBJ_MAYBE_AOUT) \ 441 && !defined (OBJ_BOUT) && !defined (OBJ_MAYBE_BOUT)) 442 static const char *od_buf = ""; 443#else 444 char od_buf[100]; 445 od_buf[0] = '\0'; 446#ifdef BFD_ASSEMBLER 447 if (OUTPUT_FLAVOR == bfd_target_aout_flavour) 448#endif 449 sprintf(od_buf, "%d.%d.", 450 S_GET_OTHER (symbolP), 451 S_GET_DESC (symbolP)); 452#endif 453 as_fatal (_("Symbol \"%s\" is already defined as \"%s\"/%s%ld."), 454 sym_name, 455 segment_name (S_GET_SEGMENT (symbolP)), 456 od_buf, 457 (long) S_GET_VALUE (symbolP)); 458 } 459 } /* if the undefined symbol has no value */ 460 } 461 else 462 { 463 /* Don't blow up if the definition is the same */ 464 if (!(frag_now == symbolP->sy_frag 465 && S_GET_VALUE (symbolP) == frag_now_fix () 466 && S_GET_SEGMENT (symbolP) == now_seg)) 467 as_fatal (_("Symbol %s already defined."), sym_name); 468 } /* if this symbol is not yet defined */ 469 470 } 471#ifdef BFD_ASSEMBLER 472 else if (! flag_keep_locals && bfd_is_local_label_name (stdoutput, sym_name)) 473 { 474 symbolP = (symbolS *) local_symbol_make (sym_name, now_seg, 475 (valueT) frag_now_fix (), 476 frag_now); 477 } 478#endif /* BFD_ASSEMBLER */ 479 else 480 { 481 symbolP = symbol_new (sym_name, now_seg, (valueT) frag_now_fix (), 482 frag_now); 483#ifdef OBJ_VMS 484 S_SET_OTHER (symbolP, const_flag); 485#endif /* OBJ_VMS */ 486 487 symbol_table_insert (symbolP); 488 } /* if we have seen this symbol before */ 489 490 if (mri_common_symbol != NULL) 491 { 492 /* This symbol is actually being defined within an MRI common 493 section. This requires special handling. */ 494 if (LOCAL_SYMBOL_CHECK (symbolP)) 495 symbolP = local_symbol_convert ((struct local_symbol *) symbolP); 496 symbolP->sy_value.X_op = O_symbol; 497 symbolP->sy_value.X_add_symbol = mri_common_symbol; 498 symbolP->sy_value.X_add_number = S_GET_VALUE (mri_common_symbol); 499 symbolP->sy_frag = &zero_address_frag; 500 S_SET_SEGMENT (symbolP, expr_section); 501 symbolP->sy_mri_common = 1; 502 } 503 504#ifdef tc_frob_label 505 tc_frob_label (symbolP); 506#endif 507#ifdef obj_frob_label 508 obj_frob_label (symbolP); 509#endif 510 511 return symbolP; 512} 513 514 515/* 516 * symbol_table_insert() 517 * 518 * Die if we can't insert the symbol. 519 * 520 */ 521 522void 523symbol_table_insert (symbolP) 524 symbolS *symbolP; 525{ 526 register const char *error_string; 527 528 know (symbolP); 529 know (S_GET_NAME (symbolP)); 530 531 if (LOCAL_SYMBOL_CHECK (symbolP)) 532 { 533 error_string = hash_jam (local_hash, S_GET_NAME (symbolP), 534 (PTR) symbolP); 535 if (error_string != NULL) 536 as_fatal (_("Inserting \"%s\" into symbol table failed: %s"), 537 S_GET_NAME (symbolP), error_string); 538 return; 539 } 540 541 if ((error_string = hash_jam (sy_hash, S_GET_NAME (symbolP), (PTR) symbolP))) 542 { 543 as_fatal (_("Inserting \"%s\" into symbol table failed: %s"), 544 S_GET_NAME (symbolP), error_string); 545 } /* on error */ 546} /* symbol_table_insert() */ 547 548/* 549 * symbol_find_or_make() 550 * 551 * If a symbol name does not exist, create it as undefined, and insert 552 * it into the symbol table. Return a pointer to it. 553 */ 554symbolS * 555symbol_find_or_make (name) 556 const char *name; 557{ 558 register symbolS *symbolP; 559 560 symbolP = symbol_find (name); 561 562 if (symbolP == NULL) 563 { 564#ifdef BFD_ASSEMBLER 565 if (! flag_keep_locals && bfd_is_local_label_name (stdoutput, name)) 566 { 567 symbolP = md_undefined_symbol ((char *) name); 568 if (symbolP != NULL) 569 return symbolP; 570 571 symbolP = (symbolS *) local_symbol_make (name, undefined_section, 572 (valueT) 0, 573 &zero_address_frag); 574 return symbolP; 575 } 576#endif 577 578 symbolP = symbol_make (name); 579 580 symbol_table_insert (symbolP); 581 } /* if symbol wasn't found */ 582 583 return (symbolP); 584} /* symbol_find_or_make() */ 585 586symbolS * 587symbol_make (name) 588 CONST char *name; 589{ 590 symbolS *symbolP; 591 592 /* Let the machine description default it, e.g. for register names. */ 593 symbolP = md_undefined_symbol ((char *) name); 594 595 if (!symbolP) 596 symbolP = symbol_new (name, undefined_section, (valueT) 0, &zero_address_frag); 597 598 return (symbolP); 599} /* symbol_make() */ 600 601/* 602 * symbol_find() 603 * 604 * Implement symbol table lookup. 605 * In: A symbol's name as a string: '\0' can't be part of a symbol name. 606 * Out: NULL if the name was not in the symbol table, else the address 607 * of a struct symbol associated with that name. 608 */ 609 610symbolS * 611symbol_find (name) 612 CONST char *name; 613{ 614#ifdef STRIP_UNDERSCORE 615 return (symbol_find_base (name, 1)); 616#else /* STRIP_UNDERSCORE */ 617 return (symbol_find_base (name, 0)); 618#endif /* STRIP_UNDERSCORE */ 619} /* symbol_find() */ 620 621symbolS * 622symbol_find_base (name, strip_underscore) 623 CONST char *name; 624 int strip_underscore; 625{ 626 if (strip_underscore && *name == '_') 627 name++; 628 629#ifdef tc_canonicalize_symbol_name 630 { 631 char *copy; 632 size_t len = strlen (name) + 1; 633 634 copy = (char *) alloca (len); 635 memcpy (copy, name, len); 636 name = tc_canonicalize_symbol_name (copy); 637 } 638#endif 639 640 if (! symbols_case_sensitive) 641 { 642 char *copy; 643 const char *orig; 644 unsigned char c; 645 646 orig = name; 647 name = copy = (char *) alloca (strlen (name) + 1); 648 649 while ((c = *orig++) != '\0') 650 { 651 if (islower (c)) 652 c = toupper (c); 653 *copy++ = c; 654 } 655 *copy = '\0'; 656 } 657 658#ifdef BFD_ASSEMBLER 659 { 660 struct local_symbol *locsym; 661 662 locsym = (struct local_symbol *) hash_find (local_hash, name); 663 if (locsym != NULL) 664 return (symbolS *) locsym; 665 } 666#endif 667 668 return ((symbolS *) hash_find (sy_hash, name)); 669} 670 671/* 672 * Once upon a time, symbols were kept in a singly linked list. At 673 * least coff needs to be able to rearrange them from time to time, for 674 * which a doubly linked list is much more convenient. Loic did these 675 * as macros which seemed dangerous to me so they're now functions. 676 * xoxorich. 677 */ 678 679/* Link symbol ADDME after symbol TARGET in the chain. */ 680void 681symbol_append (addme, target, rootPP, lastPP) 682 symbolS *addme; 683 symbolS *target; 684 symbolS **rootPP; 685 symbolS **lastPP; 686{ 687 if (LOCAL_SYMBOL_CHECK (addme)) 688 abort (); 689 if (target != NULL && LOCAL_SYMBOL_CHECK (target)) 690 abort (); 691 692 if (target == NULL) 693 { 694 know (*rootPP == NULL); 695 know (*lastPP == NULL); 696 addme->sy_next = NULL; 697#ifdef SYMBOLS_NEED_BACKPOINTERS 698 addme->sy_previous = NULL; 699#endif 700 *rootPP = addme; 701 *lastPP = addme; 702 return; 703 } /* if the list is empty */ 704 705 if (target->sy_next != NULL) 706 { 707#ifdef SYMBOLS_NEED_BACKPOINTERS 708 target->sy_next->sy_previous = addme; 709#endif /* SYMBOLS_NEED_BACKPOINTERS */ 710 } 711 else 712 { 713 know (*lastPP == target); 714 *lastPP = addme; 715 } /* if we have a next */ 716 717 addme->sy_next = target->sy_next; 718 target->sy_next = addme; 719 720#ifdef SYMBOLS_NEED_BACKPOINTERS 721 addme->sy_previous = target; 722#endif /* SYMBOLS_NEED_BACKPOINTERS */ 723 724 debug_verify_symchain (symbol_rootP, symbol_lastP); 725} 726 727/* Set the chain pointers of SYMBOL to null. */ 728void 729symbol_clear_list_pointers (symbolP) 730 symbolS *symbolP; 731{ 732 if (LOCAL_SYMBOL_CHECK (symbolP)) 733 abort (); 734 symbolP->sy_next = NULL; 735#ifdef SYMBOLS_NEED_BACKPOINTERS 736 symbolP->sy_previous = NULL; 737#endif 738} 739 740#ifdef SYMBOLS_NEED_BACKPOINTERS 741/* Remove SYMBOLP from the list. */ 742void 743symbol_remove (symbolP, rootPP, lastPP) 744 symbolS *symbolP; 745 symbolS **rootPP; 746 symbolS **lastPP; 747{ 748 if (LOCAL_SYMBOL_CHECK (symbolP)) 749 abort (); 750 751 if (symbolP == *rootPP) 752 { 753 *rootPP = symbolP->sy_next; 754 } /* if it was the root */ 755 756 if (symbolP == *lastPP) 757 { 758 *lastPP = symbolP->sy_previous; 759 } /* if it was the tail */ 760 761 if (symbolP->sy_next != NULL) 762 { 763 symbolP->sy_next->sy_previous = symbolP->sy_previous; 764 } /* if not last */ 765 766 if (symbolP->sy_previous != NULL) 767 { 768 symbolP->sy_previous->sy_next = symbolP->sy_next; 769 } /* if not first */ 770 771 debug_verify_symchain (*rootPP, *lastPP); 772} 773 774/* Link symbol ADDME before symbol TARGET in the chain. */ 775void 776symbol_insert (addme, target, rootPP, lastPP) 777 symbolS *addme; 778 symbolS *target; 779 symbolS **rootPP; 780 symbolS **lastPP ATTRIBUTE_UNUSED; 781{ 782 if (LOCAL_SYMBOL_CHECK (addme)) 783 abort (); 784 if (LOCAL_SYMBOL_CHECK (target)) 785 abort (); 786 787 if (target->sy_previous != NULL) 788 { 789 target->sy_previous->sy_next = addme; 790 } 791 else 792 { 793 know (*rootPP == target); 794 *rootPP = addme; 795 } /* if not first */ 796 797 addme->sy_previous = target->sy_previous; 798 target->sy_previous = addme; 799 addme->sy_next = target; 800 801 debug_verify_symchain (*rootPP, *lastPP); 802} 803 804#endif /* SYMBOLS_NEED_BACKPOINTERS */ 805 806void 807verify_symbol_chain (rootP, lastP) 808 symbolS *rootP; 809 symbolS *lastP; 810{ 811 symbolS *symbolP = rootP; 812 813 if (symbolP == NULL) 814 return; 815 816 for (; symbol_next (symbolP) != NULL; symbolP = symbol_next (symbolP)) 817 { 818#ifdef BFD_ASSEMBLER 819 assert (symbolP->bsym != NULL); 820#endif 821#ifdef SYMBOLS_NEED_BACKPOINTERS 822 assert (symbolP->sy_next->sy_previous == symbolP); 823#else 824 /* Walk the list anyways, to make sure pointers are still good. */ 825 ; 826#endif /* SYMBOLS_NEED_BACKPOINTERS */ 827 } 828 829 assert (lastP == symbolP); 830} 831 832void 833verify_symbol_chain_2 (sym) 834 symbolS *sym; 835{ 836 symbolS *p = sym, *n = sym; 837#ifdef SYMBOLS_NEED_BACKPOINTERS 838 while (symbol_previous (p)) 839 p = symbol_previous (p); 840#endif 841 while (symbol_next (n)) 842 n = symbol_next (n); 843 verify_symbol_chain (p, n); 844} 845 846/* Resolve the value of a symbol. This is called during the final 847 pass over the symbol table to resolve any symbols with complex 848 values. */ 849 850valueT 851resolve_symbol_value (symp, finalize) 852 symbolS *symp; 853 int finalize; 854{ 855 int resolved; 856 valueT final_val; 857 segT final_seg; 858 859#ifdef BFD_ASSEMBLER 860 if (LOCAL_SYMBOL_CHECK (symp)) 861 { 862 struct local_symbol *locsym = (struct local_symbol *) symp; 863 864 if (local_symbol_resolved_p (locsym)) 865 return locsym->lsy_offset / OCTETS_PER_BYTE; 866 867 final_val = (local_symbol_get_frag (locsym)->fr_address 868 + locsym->lsy_offset) / OCTETS_PER_BYTE; 869 870 if (finalize) 871 { 872 locsym->lsy_offset = final_val; 873 local_symbol_mark_resolved (locsym); 874 } 875 876 return final_val; 877 } 878#endif 879 880 if (symp->sy_resolved) 881 { 882 if (symp->sy_value.X_op == O_constant) 883 return (valueT) symp->sy_value.X_add_number; 884 else 885 return 0; 886 } 887 888 resolved = 0; 889 final_seg = S_GET_SEGMENT (symp); 890 891 if (symp->sy_resolving) 892 { 893 if (finalize) 894 as_bad (_("Symbol definition loop encountered at %s"), S_GET_NAME (symp)); 895 final_val = 0; 896 resolved = 1; 897 } 898 else 899 { 900 symbolS *add_symbol, *op_symbol; 901 offsetT left, right; 902 segT seg_left, seg_right; 903 operatorT op; 904 905 symp->sy_resolving = 1; 906 907 /* Help out with CSE. */ 908 add_symbol = symp->sy_value.X_add_symbol; 909 op_symbol = symp->sy_value.X_op_symbol; 910 final_val = symp->sy_value.X_add_number; 911 op = symp->sy_value.X_op; 912 913 switch (op) 914 { 915 default: 916 BAD_CASE (op); 917 break; 918 919 case O_absent: 920 final_val = 0; 921 /* Fall through. */ 922 923 case O_constant: 924 final_val += symp->sy_frag->fr_address / OCTETS_PER_BYTE; 925 if (final_seg == expr_section) 926 final_seg = absolute_section; 927 resolved = 1; 928 break; 929 930 case O_symbol: 931 case O_symbol_rva: 932 left = resolve_symbol_value (add_symbol, finalize); 933 do_symbol: 934 935 if (symp->sy_mri_common) 936 { 937 /* This is a symbol inside an MRI common section. The 938 relocation routines are going to handle it specially. 939 Don't change the value. */ 940 resolved = symbol_resolved_p (add_symbol); 941 break; 942 } 943 944 if (finalize && final_val == 0) 945 { 946 if (LOCAL_SYMBOL_CHECK (add_symbol)) 947 add_symbol = local_symbol_convert ((struct local_symbol *) 948 add_symbol); 949 copy_symbol_attributes (symp, add_symbol); 950 } 951 952 /* If we have equated this symbol to an undefined symbol, we 953 keep X_op set to O_symbol, and we don't change 954 X_add_number. This permits the routine which writes out 955 relocation to detect this case, and convert the 956 relocation to be against the symbol to which this symbol 957 is equated. */ 958 if (! S_IS_DEFINED (add_symbol) || S_IS_COMMON (add_symbol)) 959 { 960 if (finalize) 961 { 962 S_SET_SEGMENT (symp, S_GET_SEGMENT (add_symbol)); 963 symp->sy_value.X_op = O_symbol; 964 symp->sy_value.X_add_symbol = add_symbol; 965 symp->sy_value.X_add_number = final_val; 966 } 967 final_val = 0; 968 resolved = symbol_resolved_p (add_symbol); 969 goto exit_dont_set_value; 970 } 971 else 972 { 973 final_val += symp->sy_frag->fr_address + left; 974 if (final_seg == expr_section || final_seg == undefined_section) 975 final_seg = S_GET_SEGMENT (add_symbol); 976 } 977 978 resolved = symbol_resolved_p (add_symbol); 979 break; 980 981 case O_uminus: 982 case O_bit_not: 983 case O_logical_not: 984 left = resolve_symbol_value (add_symbol, finalize); 985 986 if (op == O_uminus) 987 left = -left; 988 else if (op == O_logical_not) 989 left = !left; 990 else 991 left = ~left; 992 993 final_val += left + symp->sy_frag->fr_address; 994 if (final_seg == expr_section || final_seg == undefined_section) 995 final_seg = absolute_section; 996 997 resolved = symbol_resolved_p (add_symbol); 998 break; 999 1000 case O_multiply: 1001 case O_divide: 1002 case O_modulus: 1003 case O_left_shift: 1004 case O_right_shift: 1005 case O_bit_inclusive_or: 1006 case O_bit_or_not: 1007 case O_bit_exclusive_or: 1008 case O_bit_and: 1009 case O_add: 1010 case O_subtract: 1011 case O_eq: 1012 case O_ne: 1013 case O_lt: 1014 case O_le: 1015 case O_ge: 1016 case O_gt: 1017 case O_logical_and: 1018 case O_logical_or: 1019 left = resolve_symbol_value (add_symbol, finalize); 1020 right = resolve_symbol_value (op_symbol, finalize); 1021 seg_left = S_GET_SEGMENT (add_symbol); 1022 seg_right = S_GET_SEGMENT (op_symbol); 1023 1024 /* Simplify addition or subtraction of a constant by folding the 1025 constant into X_add_number. */ 1026 if (op == O_add || op == O_subtract) 1027 { 1028 if (seg_right == absolute_section) 1029 { 1030 if (op == O_add) 1031 final_val += right; 1032 else 1033 final_val -= right; 1034 op = O_symbol; 1035 op_symbol = NULL; 1036 goto do_symbol; 1037 } 1038 else if (seg_left == absolute_section && op == O_add) 1039 { 1040 op = O_symbol; 1041 final_val += left; 1042 add_symbol = op_symbol; 1043 left = right; 1044 op_symbol = NULL; 1045 goto do_symbol; 1046 } 1047 } 1048 1049 /* Subtraction is permitted if both operands are in the same 1050 section. Otherwise, both operands must be absolute. We 1051 already handled the case of addition or subtraction of a 1052 constant above. This will probably need to be changed 1053 for an object file format which supports arbitrary 1054 expressions, such as IEEE-695. */ 1055 /* Don't emit messages unless we're finalizing the symbol value, 1056 otherwise we may get the same message multiple times. */ 1057 if ((seg_left != absolute_section 1058 || seg_right != absolute_section) 1059 && (op != O_subtract 1060 || seg_left != seg_right 1061 || seg_left == undefined_section) 1062 && finalize) 1063 { 1064 char *file; 1065 unsigned int line; 1066 1067 if (expr_symbol_where (symp, &file, &line)) 1068 { 1069 if (seg_left == undefined_section) 1070 as_bad_where (file, line, 1071 _("undefined symbol %s in operation"), 1072 S_GET_NAME (symp->sy_value.X_add_symbol)); 1073 if (seg_right == undefined_section) 1074 as_bad_where (file, line, 1075 _("undefined symbol %s in operation"), 1076 S_GET_NAME (symp->sy_value.X_op_symbol)); 1077 if (seg_left != undefined_section 1078 && seg_right != undefined_section) 1079 as_bad_where (file, line, _("invalid section for operation")); 1080 } 1081 else 1082 { 1083 if (seg_left == undefined_section) 1084 as_bad (_("undefined symbol %s in operation setting %s"), 1085 S_GET_NAME (symp->sy_value.X_add_symbol), 1086 S_GET_NAME (symp)); 1087 if (seg_right == undefined_section) 1088 as_bad (_("undefined symbol %s in operation setting %s"), 1089 S_GET_NAME (symp->sy_value.X_op_symbol), 1090 S_GET_NAME (symp)); 1091 if (seg_left != undefined_section 1092 && seg_right != undefined_section) 1093 as_bad (_("invalid section for operation setting %s"), 1094 S_GET_NAME (symp)); 1095 } 1096 } 1097 1098 /* Check for division by zero. */ 1099 if ((op == O_divide || op == O_modulus) && right == 0) 1100 { 1101 /* If seg_right is not absolute_section, then we've 1102 already issued a warning about using a bad symbol. */ 1103 if (seg_right == absolute_section && finalize) 1104 { 1105 char *file; 1106 unsigned int line; 1107 1108 if (expr_symbol_where (symp, &file, &line)) 1109 as_bad_where (file, line, _("division by zero")); 1110 else 1111 as_bad (_("division by zero when setting %s"), 1112 S_GET_NAME (symp)); 1113 } 1114 1115 right = 1; 1116 } 1117 1118 switch (symp->sy_value.X_op) 1119 { 1120 case O_multiply: left *= right; break; 1121 case O_divide: left /= right; break; 1122 case O_modulus: left %= right; break; 1123 case O_left_shift: left <<= right; break; 1124 case O_right_shift: left >>= right; break; 1125 case O_bit_inclusive_or: left |= right; break; 1126 case O_bit_or_not: left |= ~right; break; 1127 case O_bit_exclusive_or: left ^= right; break; 1128 case O_bit_and: left &= right; break; 1129 case O_add: left += right; break; 1130 case O_subtract: left -= right; break; 1131 case O_eq: left = left == right ? ~ (offsetT) 0 : 0; break; 1132 case O_ne: left = left != right ? ~ (offsetT) 0 : 0; break; 1133 case O_lt: left = left < right ? ~ (offsetT) 0 : 0; break; 1134 case O_le: left = left <= right ? ~ (offsetT) 0 : 0; break; 1135 case O_ge: left = left >= right ? ~ (offsetT) 0 : 0; break; 1136 case O_gt: left = left > right ? ~ (offsetT) 0 : 0; break; 1137 case O_logical_and: left = left && right; break; 1138 case O_logical_or: left = left || right; break; 1139 default: abort (); 1140 } 1141 1142 final_val += symp->sy_frag->fr_address + left; 1143 if (final_seg == expr_section || final_seg == undefined_section) 1144 final_seg = absolute_section; 1145 resolved = (symbol_resolved_p (add_symbol) 1146 && symbol_resolved_p (op_symbol)); 1147 break; 1148 1149 case O_register: 1150 case O_big: 1151 case O_illegal: 1152 /* Give an error (below) if not in expr_section. We don't 1153 want to worry about expr_section symbols, because they 1154 are fictional (they are created as part of expression 1155 resolution), and any problems may not actually mean 1156 anything. */ 1157 break; 1158 } 1159 1160 symp->sy_resolving = 0; 1161 } 1162 1163 if (finalize) 1164 { 1165 S_SET_VALUE (symp, final_val); 1166 1167#if defined (OBJ_AOUT) && ! defined (BFD_ASSEMBLER) 1168 /* The old a.out backend does not handle S_SET_SEGMENT correctly 1169 for a stab symbol, so we use this bad hack. */ 1170 if (final_seg != S_GET_SEGMENT (symp)) 1171#endif 1172 S_SET_SEGMENT (symp, final_seg); 1173 } 1174 1175exit_dont_set_value: 1176 /* Don't worry if we can't resolve an expr_section symbol. */ 1177 if (finalize) 1178 { 1179 if (resolved) 1180 symp->sy_resolved = 1; 1181 else if (S_GET_SEGMENT (symp) != expr_section) 1182 { 1183 as_bad (_("can't resolve value for symbol \"%s\""), S_GET_NAME (symp)); 1184 symp->sy_resolved = 1; 1185 } 1186 } 1187 1188 return final_val; 1189} 1190 1191#ifdef BFD_ASSEMBLER 1192 1193static void resolve_local_symbol PARAMS ((const char *, PTR)); 1194 1195/* A static function passed to hash_traverse. */ 1196 1197static void 1198resolve_local_symbol (key, value) 1199 const char *key ATTRIBUTE_UNUSED; 1200 PTR value; 1201{ 1202 if (value != NULL) 1203 resolve_symbol_value (value, 1); 1204} 1205 1206#endif 1207 1208/* Resolve all local symbols. */ 1209 1210void 1211resolve_local_symbol_values () 1212{ 1213#ifdef BFD_ASSEMBLER 1214 hash_traverse (local_hash, resolve_local_symbol); 1215#endif 1216} 1217 1218/* Dollar labels look like a number followed by a dollar sign. Eg, "42$". 1219 They are *really* local. That is, they go out of scope whenever we see a 1220 label that isn't local. Also, like fb labels, there can be multiple 1221 instances of a dollar label. Therefor, we name encode each instance with 1222 the instance number, keep a list of defined symbols separate from the real 1223 symbol table, and we treat these buggers as a sparse array. */ 1224 1225static long *dollar_labels; 1226static long *dollar_label_instances; 1227static char *dollar_label_defines; 1228static unsigned long dollar_label_count; 1229static unsigned long dollar_label_max; 1230 1231int 1232dollar_label_defined (label) 1233 long label; 1234{ 1235 long *i; 1236 1237 know ((dollar_labels != NULL) || (dollar_label_count == 0)); 1238 1239 for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i) 1240 if (*i == label) 1241 return dollar_label_defines[i - dollar_labels]; 1242 1243 /* if we get here, label isn't defined */ 1244 return 0; 1245} /* dollar_label_defined() */ 1246 1247static long 1248dollar_label_instance (label) 1249 long label; 1250{ 1251 long *i; 1252 1253 know ((dollar_labels != NULL) || (dollar_label_count == 0)); 1254 1255 for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i) 1256 if (*i == label) 1257 return (dollar_label_instances[i - dollar_labels]); 1258 1259 /* If we get here, we haven't seen the label before, therefore its instance 1260 count is zero. */ 1261 return 0; 1262} 1263 1264void 1265dollar_label_clear () 1266{ 1267 memset (dollar_label_defines, '\0', (unsigned int) dollar_label_count); 1268} 1269 1270#define DOLLAR_LABEL_BUMP_BY 10 1271 1272void 1273define_dollar_label (label) 1274 long label; 1275{ 1276 long *i; 1277 1278 for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i) 1279 if (*i == label) 1280 { 1281 ++dollar_label_instances[i - dollar_labels]; 1282 dollar_label_defines[i - dollar_labels] = 1; 1283 return; 1284 } 1285 1286 /* if we get to here, we don't have label listed yet. */ 1287 1288 if (dollar_labels == NULL) 1289 { 1290 dollar_labels = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long)); 1291 dollar_label_instances = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long)); 1292 dollar_label_defines = xmalloc (DOLLAR_LABEL_BUMP_BY); 1293 dollar_label_max = DOLLAR_LABEL_BUMP_BY; 1294 dollar_label_count = 0; 1295 } 1296 else if (dollar_label_count == dollar_label_max) 1297 { 1298 dollar_label_max += DOLLAR_LABEL_BUMP_BY; 1299 dollar_labels = (long *) xrealloc ((char *) dollar_labels, 1300 dollar_label_max * sizeof (long)); 1301 dollar_label_instances = (long *) xrealloc ((char *) dollar_label_instances, 1302 dollar_label_max * sizeof (long)); 1303 dollar_label_defines = xrealloc (dollar_label_defines, dollar_label_max); 1304 } /* if we needed to grow */ 1305 1306 dollar_labels[dollar_label_count] = label; 1307 dollar_label_instances[dollar_label_count] = 1; 1308 dollar_label_defines[dollar_label_count] = 1; 1309 ++dollar_label_count; 1310} 1311 1312/* 1313 * dollar_label_name() 1314 * 1315 * Caller must copy returned name: we re-use the area for the next name. 1316 * 1317 * The mth occurence of label n: is turned into the symbol "Ln^Am" 1318 * where n is the label number and m is the instance number. "L" makes 1319 * it a label discarded unless debugging and "^A"('\1') ensures no 1320 * ordinary symbol SHOULD get the same name as a local label 1321 * symbol. The first "4:" is "L4^A1" - the m numbers begin at 1. 1322 * 1323 * fb labels get the same treatment, except that ^B is used in place of ^A. 1324 */ 1325 1326char * /* Return local label name. */ 1327dollar_label_name (n, augend) 1328 register long n; /* we just saw "n$:" : n a number */ 1329 register int augend; /* 0 for current instance, 1 for new instance */ 1330{ 1331 long i; 1332 /* Returned to caller, then copied. used for created names ("4f") */ 1333 static char symbol_name_build[24]; 1334 register char *p; 1335 register char *q; 1336 char symbol_name_temporary[20]; /* build up a number, BACKWARDS */ 1337 1338 know (n >= 0); 1339 know (augend == 0 || augend == 1); 1340 p = symbol_name_build; 1341#ifdef LOCAL_LABEL_PREFIX 1342 *p++ = LOCAL_LABEL_PREFIX; 1343#endif 1344 *p++ = 'L'; 1345 1346 /* Next code just does sprintf( {}, "%d", n); */ 1347 /* label number */ 1348 q = symbol_name_temporary; 1349 for (*q++ = 0, i = n; i; ++q) 1350 { 1351 *q = i % 10 + '0'; 1352 i /= 10; 1353 } 1354 while ((*p = *--q) != '\0') 1355 ++p; 1356 1357 *p++ = 1; /* ^A */ 1358 1359 /* instance number */ 1360 q = symbol_name_temporary; 1361 for (*q++ = 0, i = dollar_label_instance (n) + augend; i; ++q) 1362 { 1363 *q = i % 10 + '0'; 1364 i /= 10; 1365 } 1366 while ((*p++ = *--q) != '\0');; 1367 1368 /* The label, as a '\0' ended string, starts at symbol_name_build. */ 1369 return symbol_name_build; 1370} 1371 1372/* 1373 * Sombody else's idea of local labels. They are made by "n:" where n 1374 * is any decimal digit. Refer to them with 1375 * "nb" for previous (backward) n: 1376 * or "nf" for next (forward) n:. 1377 * 1378 * We do a little better and let n be any number, not just a single digit, but 1379 * since the other guy's assembler only does ten, we treat the first ten 1380 * specially. 1381 * 1382 * Like someone else's assembler, we have one set of local label counters for 1383 * entire assembly, not one set per (sub)segment like in most assemblers. This 1384 * implies that one can refer to a label in another segment, and indeed some 1385 * crufty compilers have done just that. 1386 * 1387 * Since there could be a LOT of these things, treat them as a sparse array. 1388 */ 1389 1390#define FB_LABEL_SPECIAL (10) 1391 1392static long fb_low_counter[FB_LABEL_SPECIAL]; 1393static long *fb_labels; 1394static long *fb_label_instances; 1395static long fb_label_count; 1396static long fb_label_max; 1397 1398/* this must be more than FB_LABEL_SPECIAL */ 1399#define FB_LABEL_BUMP_BY (FB_LABEL_SPECIAL + 6) 1400 1401static void 1402fb_label_init () 1403{ 1404 memset ((void *) fb_low_counter, '\0', sizeof (fb_low_counter)); 1405} /* fb_label_init() */ 1406 1407/* add one to the instance number of this fb label */ 1408void 1409fb_label_instance_inc (label) 1410 long label; 1411{ 1412 long *i; 1413 1414 if (label < FB_LABEL_SPECIAL) 1415 { 1416 ++fb_low_counter[label]; 1417 return; 1418 } 1419 1420 if (fb_labels != NULL) 1421 { 1422 for (i = fb_labels + FB_LABEL_SPECIAL; 1423 i < fb_labels + fb_label_count; ++i) 1424 { 1425 if (*i == label) 1426 { 1427 ++fb_label_instances[i - fb_labels]; 1428 return; 1429 } /* if we find it */ 1430 } /* for each existing label */ 1431 } 1432 1433 /* if we get to here, we don't have label listed yet. */ 1434 1435 if (fb_labels == NULL) 1436 { 1437 fb_labels = (long *) xmalloc (FB_LABEL_BUMP_BY * sizeof (long)); 1438 fb_label_instances = (long *) xmalloc (FB_LABEL_BUMP_BY * sizeof (long)); 1439 fb_label_max = FB_LABEL_BUMP_BY; 1440 fb_label_count = FB_LABEL_SPECIAL; 1441 1442 } 1443 else if (fb_label_count == fb_label_max) 1444 { 1445 fb_label_max += FB_LABEL_BUMP_BY; 1446 fb_labels = (long *) xrealloc ((char *) fb_labels, 1447 fb_label_max * sizeof (long)); 1448 fb_label_instances = (long *) xrealloc ((char *) fb_label_instances, 1449 fb_label_max * sizeof (long)); 1450 } /* if we needed to grow */ 1451 1452 fb_labels[fb_label_count] = label; 1453 fb_label_instances[fb_label_count] = 1; 1454 ++fb_label_count; 1455} 1456 1457static long 1458fb_label_instance (label) 1459 long label; 1460{ 1461 long *i; 1462 1463 if (label < FB_LABEL_SPECIAL) 1464 { 1465 return (fb_low_counter[label]); 1466 } 1467 1468 if (fb_labels != NULL) 1469 { 1470 for (i = fb_labels + FB_LABEL_SPECIAL; 1471 i < fb_labels + fb_label_count; ++i) 1472 { 1473 if (*i == label) 1474 { 1475 return (fb_label_instances[i - fb_labels]); 1476 } /* if we find it */ 1477 } /* for each existing label */ 1478 } 1479 1480 /* We didn't find the label, so this must be a reference to the 1481 first instance. */ 1482 return 0; 1483} 1484 1485/* 1486 * fb_label_name() 1487 * 1488 * Caller must copy returned name: we re-use the area for the next name. 1489 * 1490 * The mth occurence of label n: is turned into the symbol "Ln^Bm" 1491 * where n is the label number and m is the instance number. "L" makes 1492 * it a label discarded unless debugging and "^B"('\2') ensures no 1493 * ordinary symbol SHOULD get the same name as a local label 1494 * symbol. The first "4:" is "L4^B1" - the m numbers begin at 1. 1495 * 1496 * dollar labels get the same treatment, except that ^A is used in place of ^B. */ 1497 1498char * /* Return local label name. */ 1499fb_label_name (n, augend) 1500 long n; /* we just saw "n:", "nf" or "nb" : n a number */ 1501 long augend; /* 0 for nb, 1 for n:, nf */ 1502{ 1503 long i; 1504 /* Returned to caller, then copied. used for created names ("4f") */ 1505 static char symbol_name_build[24]; 1506 register char *p; 1507 register char *q; 1508 char symbol_name_temporary[20]; /* build up a number, BACKWARDS */ 1509 1510 know (n >= 0); 1511 know (augend == 0 || augend == 1); 1512 p = symbol_name_build; 1513 *p++ = 'L'; 1514 1515 /* Next code just does sprintf( {}, "%d", n); */ 1516 /* label number */ 1517 q = symbol_name_temporary; 1518 for (*q++ = 0, i = n; i; ++q) 1519 { 1520 *q = i % 10 + '0'; 1521 i /= 10; 1522 } 1523 while ((*p = *--q) != '\0') 1524 ++p; 1525 1526 *p++ = 2; /* ^B */ 1527 1528 /* instance number */ 1529 q = symbol_name_temporary; 1530 for (*q++ = 0, i = fb_label_instance (n) + augend; i; ++q) 1531 { 1532 *q = i % 10 + '0'; 1533 i /= 10; 1534 } 1535 while ((*p++ = *--q) != '\0');; 1536 1537 /* The label, as a '\0' ended string, starts at symbol_name_build. */ 1538 return (symbol_name_build); 1539} /* fb_label_name() */ 1540 1541/* 1542 * decode name that may have been generated by foo_label_name() above. If 1543 * the name wasn't generated by foo_label_name(), then return it unaltered. 1544 * This is used for error messages. 1545 */ 1546 1547char * 1548decode_local_label_name (s) 1549 char *s; 1550{ 1551 char *p; 1552 char *symbol_decode; 1553 int label_number; 1554 int instance_number; 1555 char *type; 1556 const char *message_format = _("\"%d\" (instance number %d of a %s label)"); 1557 1558 if (s[0] != 'L') 1559 return s; 1560 1561 for (label_number = 0, p = s + 1; isdigit ((unsigned char) *p); ++p) 1562 label_number = (10 * label_number) + *p - '0'; 1563 1564 if (*p == 1) 1565 type = "dollar"; 1566 else if (*p == 2) 1567 type = "fb"; 1568 else 1569 return s; 1570 1571 for (instance_number = 0, p++; isdigit ((unsigned char) *p); ++p) 1572 instance_number = (10 * instance_number) + *p - '0'; 1573 1574 symbol_decode = obstack_alloc (¬es, strlen (message_format) + 30); 1575 sprintf (symbol_decode, message_format, label_number, instance_number, type); 1576 1577 return symbol_decode; 1578} 1579 1580/* Get the value of a symbol. */ 1581 1582valueT 1583S_GET_VALUE (s) 1584 symbolS *s; 1585{ 1586#ifdef BFD_ASSEMBLER 1587 if (LOCAL_SYMBOL_CHECK (s)) 1588 return ((struct local_symbol *) s)->lsy_offset; 1589#endif 1590 1591 if (!s->sy_resolved && s->sy_value.X_op != O_constant) 1592 resolve_symbol_value (s, 1); 1593 if (s->sy_value.X_op != O_constant) 1594 { 1595 static symbolS *recur; 1596 1597 /* FIXME: In non BFD assemblers, S_IS_DEFINED and S_IS_COMMON 1598 may call S_GET_VALUE. We use a static symbol to avoid the 1599 immediate recursion. */ 1600 if (recur == s) 1601 return (valueT) s->sy_value.X_add_number; 1602 recur = s; 1603 if (! s->sy_resolved 1604 || s->sy_value.X_op != O_symbol 1605 || (S_IS_DEFINED (s) && ! S_IS_COMMON (s))) 1606 as_bad (_("Attempt to get value of unresolved symbol %s"), 1607 S_GET_NAME (s)); 1608 recur = NULL; 1609 } 1610 return (valueT) s->sy_value.X_add_number; 1611} 1612 1613/* Set the value of a symbol. */ 1614 1615void 1616S_SET_VALUE (s, val) 1617 symbolS *s; 1618 valueT val; 1619{ 1620#ifdef BFD_ASSEMBLER 1621 if (LOCAL_SYMBOL_CHECK (s)) 1622 { 1623 ((struct local_symbol *) s)->lsy_offset = val; 1624 return; 1625 } 1626#endif 1627 1628 s->sy_value.X_op = O_constant; 1629 s->sy_value.X_add_number = (offsetT) val; 1630 s->sy_value.X_unsigned = 0; 1631} 1632 1633void 1634copy_symbol_attributes (dest, src) 1635 symbolS *dest, *src; 1636{ 1637 if (LOCAL_SYMBOL_CHECK (dest)) 1638 dest = local_symbol_convert ((struct local_symbol *) dest); 1639 if (LOCAL_SYMBOL_CHECK (src)) 1640 src = local_symbol_convert ((struct local_symbol *) src); 1641 1642#ifdef BFD_ASSEMBLER 1643 /* In an expression, transfer the settings of these flags. 1644 The user can override later, of course. */ 1645#define COPIED_SYMFLAGS (BSF_FUNCTION | BSF_OBJECT) 1646 dest->bsym->flags |= src->bsym->flags & COPIED_SYMFLAGS; 1647#endif 1648 1649#ifdef OBJ_COPY_SYMBOL_ATTRIBUTES 1650 OBJ_COPY_SYMBOL_ATTRIBUTES (dest, src); 1651#endif 1652} 1653 1654#ifdef BFD_ASSEMBLER 1655 1656int 1657S_IS_FUNCTION (s) 1658 symbolS *s; 1659{ 1660 flagword flags; 1661 1662 if (LOCAL_SYMBOL_CHECK (s)) 1663 return 0; 1664 1665 flags = s->bsym->flags; 1666 1667 return (flags & BSF_FUNCTION) != 0; 1668} 1669 1670int 1671S_IS_EXTERNAL (s) 1672 symbolS *s; 1673{ 1674 flagword flags; 1675 1676 if (LOCAL_SYMBOL_CHECK (s)) 1677 return 0; 1678 1679 flags = s->bsym->flags; 1680 1681 /* sanity check */ 1682 if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL)) 1683 abort (); 1684 1685 return (flags & BSF_GLOBAL) != 0; 1686} 1687 1688int 1689S_IS_WEAK (s) 1690 symbolS *s; 1691{ 1692 if (LOCAL_SYMBOL_CHECK (s)) 1693 return 0; 1694 return (s->bsym->flags & BSF_WEAK) != 0; 1695} 1696 1697int 1698S_IS_COMMON (s) 1699 symbolS *s; 1700{ 1701 if (LOCAL_SYMBOL_CHECK (s)) 1702 return 0; 1703 return bfd_is_com_section (s->bsym->section); 1704} 1705 1706int 1707S_IS_DEFINED (s) 1708 symbolS *s; 1709{ 1710 if (LOCAL_SYMBOL_CHECK (s)) 1711 return ((struct local_symbol *) s)->lsy_section != undefined_section; 1712 return s->bsym->section != undefined_section; 1713} 1714 1715int 1716S_IS_DEBUG (s) 1717 symbolS *s; 1718{ 1719 if (LOCAL_SYMBOL_CHECK (s)) 1720 return 0; 1721 if (s->bsym->flags & BSF_DEBUGGING) 1722 return 1; 1723 return 0; 1724} 1725 1726int 1727S_IS_LOCAL (s) 1728 symbolS *s; 1729{ 1730 flagword flags; 1731 const char *name; 1732 1733 if (LOCAL_SYMBOL_CHECK (s)) 1734 return 1; 1735 1736 flags = s->bsym->flags; 1737 1738 /* sanity check */ 1739 if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL)) 1740 abort (); 1741 1742 if (bfd_get_section (s->bsym) == reg_section) 1743 return 1; 1744 1745 if (flag_strip_local_absolute 1746 && (flags & BSF_GLOBAL) == 0 1747 && bfd_get_section (s->bsym) == absolute_section) 1748 return 1; 1749 1750 name = S_GET_NAME (s); 1751 return (name != NULL 1752 && ! S_IS_DEBUG (s) 1753 && (strchr (name, '\001') 1754 || strchr (name, '\002') 1755 || (! flag_keep_locals 1756 && (bfd_is_local_label (stdoutput, s->bsym) 1757 || (flag_mri 1758 && name[0] == '?' 1759 && name[1] == '?'))))); 1760} 1761 1762int 1763S_IS_EXTERN (s) 1764 symbolS *s; 1765{ 1766 return S_IS_EXTERNAL (s); 1767} 1768 1769int 1770S_IS_STABD (s) 1771 symbolS *s; 1772{ 1773 return S_GET_NAME (s) == 0; 1774} 1775 1776CONST char * 1777S_GET_NAME (s) 1778 symbolS *s; 1779{ 1780 if (LOCAL_SYMBOL_CHECK (s)) 1781 return ((struct local_symbol *) s)->lsy_name; 1782 return s->bsym->name; 1783} 1784 1785segT 1786S_GET_SEGMENT (s) 1787 symbolS *s; 1788{ 1789 if (LOCAL_SYMBOL_CHECK (s)) 1790 return ((struct local_symbol *) s)->lsy_section; 1791 return s->bsym->section; 1792} 1793 1794void 1795S_SET_SEGMENT (s, seg) 1796 symbolS *s; 1797 segT seg; 1798{ 1799 /* Don't reassign section symbols. The direct reason is to prevent seg 1800 faults assigning back to const global symbols such as *ABS*, but it 1801 shouldn't happen anyway. */ 1802 1803 if (LOCAL_SYMBOL_CHECK (s)) 1804 { 1805 if (seg == reg_section) 1806 s = local_symbol_convert ((struct local_symbol *) s); 1807 else 1808 { 1809 ((struct local_symbol *) s)->lsy_section = seg; 1810 return; 1811 } 1812 } 1813 1814 if (s->bsym->flags & BSF_SECTION_SYM) 1815 { 1816 if (s->bsym->section != seg) 1817 abort(); 1818 } 1819 else 1820 s->bsym->section = seg; 1821} 1822 1823void 1824S_SET_EXTERNAL (s) 1825 symbolS *s; 1826{ 1827 if (LOCAL_SYMBOL_CHECK (s)) 1828 s = local_symbol_convert ((struct local_symbol *) s); 1829 if ((s->bsym->flags & BSF_WEAK) != 0) 1830 { 1831 /* Let .weak override .global. */ 1832 return; 1833 } 1834 s->bsym->flags |= BSF_GLOBAL; 1835 s->bsym->flags &= ~(BSF_LOCAL|BSF_WEAK); 1836} 1837 1838void 1839S_CLEAR_EXTERNAL (s) 1840 symbolS *s; 1841{ 1842 if (LOCAL_SYMBOL_CHECK (s)) 1843 return; 1844 if ((s->bsym->flags & BSF_WEAK) != 0) 1845 { 1846 /* Let .weak override. */ 1847 return; 1848 } 1849 s->bsym->flags |= BSF_LOCAL; 1850 s->bsym->flags &= ~(BSF_GLOBAL|BSF_WEAK); 1851} 1852 1853void 1854S_SET_WEAK (s) 1855 symbolS *s; 1856{ 1857 if (LOCAL_SYMBOL_CHECK (s)) 1858 s = local_symbol_convert ((struct local_symbol *) s); 1859 s->bsym->flags |= BSF_WEAK; 1860 s->bsym->flags &= ~(BSF_GLOBAL|BSF_LOCAL); 1861} 1862 1863void 1864S_SET_NAME (s, name) 1865 symbolS *s; 1866 char *name; 1867{ 1868 if (LOCAL_SYMBOL_CHECK (s)) 1869 { 1870 ((struct local_symbol *) s)->lsy_name = name; 1871 return; 1872 } 1873 s->bsym->name = name; 1874} 1875#endif /* BFD_ASSEMBLER */ 1876 1877#ifdef SYMBOLS_NEED_BACKPOINTERS 1878 1879/* Return the previous symbol in a chain. */ 1880 1881symbolS * 1882symbol_previous (s) 1883 symbolS *s; 1884{ 1885 if (LOCAL_SYMBOL_CHECK (s)) 1886 abort (); 1887 return s->sy_previous; 1888} 1889 1890#endif /* SYMBOLS_NEED_BACKPOINTERS */ 1891 1892/* Return the next symbol in a chain. */ 1893 1894symbolS * 1895symbol_next (s) 1896 symbolS *s; 1897{ 1898 if (LOCAL_SYMBOL_CHECK (s)) 1899 abort (); 1900 return s->sy_next; 1901} 1902 1903/* Return a pointer to the value of a symbol as an expression. */ 1904 1905expressionS * 1906symbol_get_value_expression (s) 1907 symbolS *s; 1908{ 1909 if (LOCAL_SYMBOL_CHECK (s)) 1910 s = local_symbol_convert ((struct local_symbol *) s); 1911 return &s->sy_value; 1912} 1913 1914/* Set the value of a symbol to an expression. */ 1915 1916void 1917symbol_set_value_expression (s, exp) 1918 symbolS *s; 1919 const expressionS *exp; 1920{ 1921 if (LOCAL_SYMBOL_CHECK (s)) 1922 s = local_symbol_convert ((struct local_symbol *) s); 1923 s->sy_value = *exp; 1924} 1925 1926/* Set the frag of a symbol. */ 1927 1928void 1929symbol_set_frag (s, f) 1930 symbolS *s; 1931 fragS *f; 1932{ 1933#ifdef BFD_ASSEMBLER 1934 if (LOCAL_SYMBOL_CHECK (s)) 1935 { 1936 local_symbol_set_frag ((struct local_symbol *) s, f); 1937 return; 1938 } 1939#endif 1940 s->sy_frag = f; 1941} 1942 1943/* Return the frag of a symbol. */ 1944 1945fragS * 1946symbol_get_frag (s) 1947 symbolS *s; 1948{ 1949#ifdef BFD_ASSEMBLER 1950 if (LOCAL_SYMBOL_CHECK (s)) 1951 return local_symbol_get_frag ((struct local_symbol *) s); 1952#endif 1953 return s->sy_frag; 1954} 1955 1956/* Mark a symbol as having been used. */ 1957 1958void 1959symbol_mark_used (s) 1960 symbolS *s; 1961{ 1962 if (LOCAL_SYMBOL_CHECK (s)) 1963 return; 1964 s->sy_used = 1; 1965} 1966 1967/* Clear the mark of whether a symbol has been used. */ 1968 1969void 1970symbol_clear_used (s) 1971 symbolS *s; 1972{ 1973 if (LOCAL_SYMBOL_CHECK (s)) 1974 s = local_symbol_convert ((struct local_symbol *) s); 1975 s->sy_used = 0; 1976} 1977 1978/* Return whether a symbol has been used. */ 1979 1980int 1981symbol_used_p (s) 1982 symbolS *s; 1983{ 1984 if (LOCAL_SYMBOL_CHECK (s)) 1985 return 1; 1986 return s->sy_used; 1987} 1988 1989/* Mark a symbol as having been used in a reloc. */ 1990 1991void 1992symbol_mark_used_in_reloc (s) 1993 symbolS *s; 1994{ 1995 if (LOCAL_SYMBOL_CHECK (s)) 1996 s = local_symbol_convert ((struct local_symbol *) s); 1997 s->sy_used_in_reloc = 1; 1998} 1999 2000/* Clear the mark of whether a symbol has been used in a reloc. */ 2001 2002void 2003symbol_clear_used_in_reloc (s) 2004 symbolS *s; 2005{ 2006 if (LOCAL_SYMBOL_CHECK (s)) 2007 return; 2008 s->sy_used_in_reloc = 0; 2009} 2010 2011/* Return whether a symbol has been used in a reloc. */ 2012 2013int 2014symbol_used_in_reloc_p (s) 2015 symbolS *s; 2016{ 2017 if (LOCAL_SYMBOL_CHECK (s)) 2018 return 0; 2019 return s->sy_used_in_reloc; 2020} 2021 2022/* Mark a symbol as an MRI common symbol. */ 2023 2024void 2025symbol_mark_mri_common (s) 2026 symbolS *s; 2027{ 2028 if (LOCAL_SYMBOL_CHECK (s)) 2029 s = local_symbol_convert ((struct local_symbol *) s); 2030 s->sy_mri_common = 1; 2031} 2032 2033/* Clear the mark of whether a symbol is an MRI common symbol. */ 2034 2035void 2036symbol_clear_mri_common (s) 2037 symbolS *s; 2038{ 2039 if (LOCAL_SYMBOL_CHECK (s)) 2040 return; 2041 s->sy_mri_common = 0; 2042} 2043 2044/* Return whether a symbol is an MRI common symbol. */ 2045 2046int 2047symbol_mri_common_p (s) 2048 symbolS *s; 2049{ 2050 if (LOCAL_SYMBOL_CHECK (s)) 2051 return 0; 2052 return s->sy_mri_common; 2053} 2054 2055/* Mark a symbol as having been written. */ 2056 2057void 2058symbol_mark_written (s) 2059 symbolS *s; 2060{ 2061 if (LOCAL_SYMBOL_CHECK (s)) 2062 return; 2063 s->written = 1; 2064} 2065 2066/* Clear the mark of whether a symbol has been written. */ 2067 2068void 2069symbol_clear_written (s) 2070 symbolS *s; 2071{ 2072 if (LOCAL_SYMBOL_CHECK (s)) 2073 return; 2074 s->written = 0; 2075} 2076 2077/* Return whether a symbol has been written. */ 2078 2079int 2080symbol_written_p (s) 2081 symbolS *s; 2082{ 2083 if (LOCAL_SYMBOL_CHECK (s)) 2084 return 0; 2085 return s->written; 2086} 2087 2088/* Mark a symbol has having been resolved. */ 2089 2090void 2091symbol_mark_resolved (s) 2092 symbolS *s; 2093{ 2094#ifdef BFD_ASSEMBLER 2095 if (LOCAL_SYMBOL_CHECK (s)) 2096 { 2097 local_symbol_mark_resolved ((struct local_symbol *) s); 2098 return; 2099 } 2100#endif 2101 s->sy_resolved = 1; 2102} 2103 2104/* Return whether a symbol has been resolved. */ 2105 2106int 2107symbol_resolved_p (s) 2108 symbolS *s; 2109{ 2110#ifdef BFD_ASSEMBLER 2111 if (LOCAL_SYMBOL_CHECK (s)) 2112 return local_symbol_resolved_p ((struct local_symbol *) s); 2113#endif 2114 return s->sy_resolved; 2115} 2116 2117/* Return whether a symbol is a section symbol. */ 2118 2119int 2120symbol_section_p (s) 2121 symbolS *s ATTRIBUTE_UNUSED; 2122{ 2123 if (LOCAL_SYMBOL_CHECK (s)) 2124 return 0; 2125#ifdef BFD_ASSEMBLER 2126 return (s->bsym->flags & BSF_SECTION_SYM) != 0; 2127#else 2128 /* FIXME */ 2129 return 0; 2130#endif 2131} 2132 2133/* Return whether a symbol is equated to another symbol. */ 2134 2135int 2136symbol_equated_p (s) 2137 symbolS *s; 2138{ 2139 if (LOCAL_SYMBOL_CHECK (s)) 2140 return 0; 2141 return s->sy_value.X_op == O_symbol; 2142} 2143 2144/* Return whether a symbol has a constant value. */ 2145 2146int 2147symbol_constant_p (s) 2148 symbolS *s; 2149{ 2150 if (LOCAL_SYMBOL_CHECK (s)) 2151 return 1; 2152 return s->sy_value.X_op == O_constant; 2153} 2154 2155#ifdef BFD_ASSEMBLER 2156 2157/* Return the BFD symbol for a symbol. */ 2158 2159asymbol * 2160symbol_get_bfdsym (s) 2161 symbolS *s; 2162{ 2163 if (LOCAL_SYMBOL_CHECK (s)) 2164 s = local_symbol_convert ((struct local_symbol *) s); 2165 return s->bsym; 2166} 2167 2168/* Set the BFD symbol for a symbol. */ 2169 2170void 2171symbol_set_bfdsym (s, bsym) 2172 symbolS *s; 2173 asymbol *bsym; 2174{ 2175 if (LOCAL_SYMBOL_CHECK (s)) 2176 s = local_symbol_convert ((struct local_symbol *) s); 2177 s->bsym = bsym; 2178} 2179 2180#endif /* BFD_ASSEMBLER */ 2181 2182#ifdef OBJ_SYMFIELD_TYPE 2183 2184/* Get a pointer to the object format information for a symbol. */ 2185 2186OBJ_SYMFIELD_TYPE * 2187symbol_get_obj (s) 2188 symbolS *s; 2189{ 2190 if (LOCAL_SYMBOL_CHECK (s)) 2191 s = local_symbol_convert ((struct local_symbol *) s); 2192 return &s->sy_obj; 2193} 2194 2195/* Set the object format information for a symbol. */ 2196 2197void 2198symbol_set_obj (s, o) 2199 symbolS *s; 2200 OBJ_SYMFIELD_TYPE *o; 2201{ 2202 if (LOCAL_SYMBOL_CHECK (s)) 2203 s = local_symbol_convert ((struct local_symbol *) s); 2204 s->sy_obj = *o; 2205} 2206 2207#endif /* OBJ_SYMFIELD_TYPE */ 2208 2209#ifdef TC_SYMFIELD_TYPE 2210 2211/* Get a pointer to the processor information for a symbol. */ 2212 2213TC_SYMFIELD_TYPE * 2214symbol_get_tc (s) 2215 symbolS *s; 2216{ 2217 if (LOCAL_SYMBOL_CHECK (s)) 2218 s = local_symbol_convert ((struct local_symbol *) s); 2219 return &s->sy_tc; 2220} 2221 2222/* Set the processor information for a symbol. */ 2223 2224void 2225symbol_set_tc (s, o) 2226 symbolS *s; 2227 TC_SYMFIELD_TYPE *o; 2228{ 2229 if (LOCAL_SYMBOL_CHECK (s)) 2230 s = local_symbol_convert ((struct local_symbol *) s); 2231 s->sy_tc = *o; 2232} 2233 2234#endif /* TC_SYMFIELD_TYPE */ 2235 2236void 2237symbol_begin () 2238{ 2239 symbol_lastP = NULL; 2240 symbol_rootP = NULL; /* In case we have 0 symbols (!!) */ 2241 sy_hash = hash_new (); 2242#ifdef BFD_ASSEMBLER 2243 local_hash = hash_new (); 2244#endif 2245 2246 memset ((char *) (&abs_symbol), '\0', sizeof (abs_symbol)); 2247#ifdef BFD_ASSEMBLER 2248#if defined (EMIT_SECTION_SYMBOLS) || !defined (RELOC_REQUIRES_SYMBOL) 2249 abs_symbol.bsym = bfd_abs_section.symbol; 2250#endif 2251#else 2252 /* Can't initialise a union. Sigh. */ 2253 S_SET_SEGMENT (&abs_symbol, absolute_section); 2254#endif 2255 abs_symbol.sy_value.X_op = O_constant; 2256 abs_symbol.sy_frag = &zero_address_frag; 2257 2258 if (LOCAL_LABELS_FB) 2259 fb_label_init (); 2260} 2261 2262 2263 2264int indent_level; 2265 2266/* Maximum indent level. 2267 Available for modification inside a gdb session. */ 2268int max_indent_level = 8; 2269 2270#if 0 2271 2272static void 2273indent () 2274{ 2275 printf ("%*s", indent_level * 4, ""); 2276} 2277 2278#endif 2279 2280void 2281print_symbol_value_1 (file, sym) 2282 FILE *file; 2283 symbolS *sym; 2284{ 2285 const char *name = S_GET_NAME (sym); 2286 if (!name || !name[0]) 2287 name = "(unnamed)"; 2288 fprintf (file, "sym %lx %s", (unsigned long) sym, name); 2289 2290 if (LOCAL_SYMBOL_CHECK (sym)) 2291 { 2292#ifdef BFD_ASSEMBLER 2293 struct local_symbol *locsym = (struct local_symbol *) sym; 2294 if (local_symbol_get_frag (locsym) != &zero_address_frag 2295 && local_symbol_get_frag (locsym) != NULL) 2296 fprintf (file, " frag %lx", (long) local_symbol_get_frag (locsym)); 2297 if (local_symbol_resolved_p (locsym)) 2298 fprintf (file, " resolved"); 2299 fprintf (file, " local"); 2300#endif 2301 } 2302 else 2303 { 2304 if (sym->sy_frag != &zero_address_frag) 2305 fprintf (file, " frag %lx", (long) sym->sy_frag); 2306 if (sym->written) 2307 fprintf (file, " written"); 2308 if (sym->sy_resolved) 2309 fprintf (file, " resolved"); 2310 else if (sym->sy_resolving) 2311 fprintf (file, " resolving"); 2312 if (sym->sy_used_in_reloc) 2313 fprintf (file, " used-in-reloc"); 2314 if (sym->sy_used) 2315 fprintf (file, " used"); 2316 if (S_IS_LOCAL (sym)) 2317 fprintf (file, " local"); 2318 if (S_IS_EXTERN (sym)) 2319 fprintf (file, " extern"); 2320 if (S_IS_DEBUG (sym)) 2321 fprintf (file, " debug"); 2322 if (S_IS_DEFINED (sym)) 2323 fprintf (file, " defined"); 2324 } 2325 fprintf (file, " %s", segment_name (S_GET_SEGMENT (sym))); 2326 if (symbol_resolved_p (sym)) 2327 { 2328 segT s = S_GET_SEGMENT (sym); 2329 2330 if (s != undefined_section 2331 && s != expr_section) 2332 fprintf (file, " %lx", (long) S_GET_VALUE (sym)); 2333 } 2334 else if (indent_level < max_indent_level 2335 && S_GET_SEGMENT (sym) != undefined_section) 2336 { 2337 indent_level++; 2338 fprintf (file, "\n%*s<", indent_level * 4, ""); 2339#ifdef BFD_ASSEMBLER 2340 if (LOCAL_SYMBOL_CHECK (sym)) 2341 fprintf (file, "constant %lx", 2342 (long) ((struct local_symbol *) sym)->lsy_offset); 2343 else 2344#endif 2345 print_expr_1 (file, &sym->sy_value); 2346 fprintf (file, ">"); 2347 indent_level--; 2348 } 2349 fflush (file); 2350} 2351 2352void 2353print_symbol_value (sym) 2354 symbolS *sym; 2355{ 2356 indent_level = 0; 2357 print_symbol_value_1 (stderr, sym); 2358 fprintf (stderr, "\n"); 2359} 2360 2361static void 2362print_binary (file, name, exp) 2363 FILE *file; 2364 const char * name; 2365 expressionS *exp; 2366{ 2367 indent_level++; 2368 fprintf (file, "%s\n%*s<", name, indent_level * 4, ""); 2369 print_symbol_value_1 (file, exp->X_add_symbol); 2370 fprintf (file, ">\n%*s<", indent_level * 4, ""); 2371 print_symbol_value_1 (file, exp->X_op_symbol); 2372 fprintf (file, ">"); 2373 indent_level--; 2374} 2375 2376void 2377print_expr_1 (file, exp) 2378 FILE *file; 2379 expressionS *exp; 2380{ 2381 fprintf (file, "expr %lx ", (long) exp); 2382 switch (exp->X_op) 2383 { 2384 case O_illegal: 2385 fprintf (file, "illegal"); 2386 break; 2387 case O_absent: 2388 fprintf (file, "absent"); 2389 break; 2390 case O_constant: 2391 fprintf (file, "constant %lx", (long) exp->X_add_number); 2392 break; 2393 case O_symbol: 2394 indent_level++; 2395 fprintf (file, "symbol\n%*s<", indent_level * 4, ""); 2396 print_symbol_value_1 (file, exp->X_add_symbol); 2397 fprintf (file, ">"); 2398 maybe_print_addnum: 2399 if (exp->X_add_number) 2400 fprintf (file, "\n%*s%lx", indent_level * 4, "", 2401 (long) exp->X_add_number); 2402 indent_level--; 2403 break; 2404 case O_register: 2405 fprintf (file, "register #%d", (int) exp->X_add_number); 2406 break; 2407 case O_big: 2408 fprintf (file, "big"); 2409 break; 2410 case O_uminus: 2411 fprintf (file, "uminus -<"); 2412 indent_level++; 2413 print_symbol_value_1 (file, exp->X_add_symbol); 2414 fprintf (file, ">"); 2415 goto maybe_print_addnum; 2416 case O_bit_not: 2417 fprintf (file, "bit_not"); 2418 break; 2419 case O_multiply: 2420 print_binary (file, "multiply", exp); 2421 break; 2422 case O_divide: 2423 print_binary (file, "divide", exp); 2424 break; 2425 case O_modulus: 2426 print_binary (file, "modulus", exp); 2427 break; 2428 case O_left_shift: 2429 print_binary (file, "lshift", exp); 2430 break; 2431 case O_right_shift: 2432 print_binary (file, "rshift", exp); 2433 break; 2434 case O_bit_inclusive_or: 2435 print_binary (file, "bit_ior", exp); 2436 break; 2437 case O_bit_exclusive_or: 2438 print_binary (file, "bit_xor", exp); 2439 break; 2440 case O_bit_and: 2441 print_binary (file, "bit_and", exp); 2442 break; 2443 case O_eq: 2444 print_binary (file, "eq", exp); 2445 break; 2446 case O_ne: 2447 print_binary (file, "ne", exp); 2448 break; 2449 case O_lt: 2450 print_binary (file, "lt", exp); 2451 break; 2452 case O_le: 2453 print_binary (file, "le", exp); 2454 break; 2455 case O_ge: 2456 print_binary (file, "ge", exp); 2457 break; 2458 case O_gt: 2459 print_binary (file, "gt", exp); 2460 break; 2461 case O_logical_and: 2462 print_binary (file, "logical_and", exp); 2463 break; 2464 case O_logical_or: 2465 print_binary (file, "logical_or", exp); 2466 break; 2467 case O_add: 2468 indent_level++; 2469 fprintf (file, "add\n%*s<", indent_level * 4, ""); 2470 print_symbol_value_1 (file, exp->X_add_symbol); 2471 fprintf (file, ">\n%*s<", indent_level * 4, ""); 2472 print_symbol_value_1 (file, exp->X_op_symbol); 2473 fprintf (file, ">"); 2474 goto maybe_print_addnum; 2475 case O_subtract: 2476 indent_level++; 2477 fprintf (file, "subtract\n%*s<", indent_level * 4, ""); 2478 print_symbol_value_1 (file, exp->X_add_symbol); 2479 fprintf (file, ">\n%*s<", indent_level * 4, ""); 2480 print_symbol_value_1 (file, exp->X_op_symbol); 2481 fprintf (file, ">"); 2482 goto maybe_print_addnum; 2483 default: 2484 fprintf (file, "{unknown opcode %d}", (int) exp->X_op); 2485 break; 2486 } 2487 fflush (stdout); 2488} 2489 2490void 2491print_expr (exp) 2492 expressionS *exp; 2493{ 2494 print_expr_1 (stderr, exp); 2495 fprintf (stderr, "\n"); 2496} 2497 2498void 2499symbol_print_statistics (file) 2500 FILE *file; 2501{ 2502 hash_print_statistics (file, "symbol table", sy_hash); 2503#ifdef BFD_ASSEMBLER 2504 hash_print_statistics (file, "mini local symbol table", local_hash); 2505 fprintf (file, "%lu mini local symbols created, %lu converted\n", 2506 local_symbol_count, local_symbol_conversion_count); 2507#endif 2508} 2509 2510/* end of symbols.c */ 2511