symbols.c revision 38889
1/* symbols.c -symbol table- 2 Copyright (C) 1987, 90, 91, 92, 93, 94, 95, 96, 97, 1998 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/* This is non-zero if symbols are case sensitive, which is the 32 default. */ 33int symbols_case_sensitive = 1; 34 35#ifndef WORKING_DOT_WORD 36extern int new_broken_words; 37#endif 38 39/* symbol-name => struct symbol pointer */ 40static struct hash_control *sy_hash; 41 42/* Below are commented in "symbols.h". */ 43symbolS *symbol_rootP; 44symbolS *symbol_lastP; 45symbolS abs_symbol; 46 47#ifdef DEBUG_SYMS 48#define debug_verify_symchain verify_symbol_chain 49#else 50#define debug_verify_symchain(root, last) ((void) 0) 51#endif 52 53struct obstack notes; 54 55static void fb_label_init PARAMS ((void)); 56static long dollar_label_instance PARAMS ((long)); 57static long fb_label_instance PARAMS ((long)); 58 59/* symbol_new() 60 61 Return a pointer to a new symbol. Die if we can't make a new 62 symbol. Fill in the symbol's values. Add symbol to end of symbol 63 chain. 64 65 This function should be called in the general case of creating a 66 symbol. However, if the output file symbol table has already been 67 set, and you are certain that this symbol won't be wanted in the 68 output file, you can call symbol_create. */ 69 70symbolS * 71symbol_new (name, segment, valu, frag) 72 const char *name; 73 segT segment; 74 valueT valu; 75 fragS *frag; 76{ 77 symbolS *symbolP = symbol_create (name, segment, valu, frag); 78 79 /* 80 * Link to end of symbol chain. 81 */ 82#ifdef BFD_ASSEMBLER 83 { 84 extern int symbol_table_frozen; 85 if (symbol_table_frozen) 86 abort (); 87 } 88#endif 89 symbol_append (symbolP, symbol_lastP, &symbol_rootP, &symbol_lastP); 90 91 return symbolP; 92} 93 94symbolS * 95symbol_create (name, segment, valu, frag) 96 const char *name; /* It is copied, the caller can destroy/modify */ 97 segT segment; /* Segment identifier (SEG_<something>) */ 98 valueT valu; /* Symbol value */ 99 fragS *frag; /* Associated fragment */ 100{ 101 unsigned int name_length; 102 char *preserved_copy_of_name; 103 symbolS *symbolP; 104 105 name_length = strlen (name) + 1; /* +1 for \0 */ 106 obstack_grow (¬es, name, name_length); 107 preserved_copy_of_name = obstack_finish (¬es); 108#ifdef STRIP_UNDERSCORE 109 if (preserved_copy_of_name[0] == '_') 110 preserved_copy_of_name++; 111#endif 112 113#ifdef tc_canonicalize_symbol_name 114 preserved_copy_of_name = 115 tc_canonicalize_symbol_name (preserved_copy_of_name); 116#endif 117 118 if (! symbols_case_sensitive) 119 { 120 unsigned char *s; 121 122 for (s = (unsigned char *) preserved_copy_of_name; *s != '\0'; s++) 123 if (islower (*s)) 124 *s = toupper (*s); 125 } 126 127 symbolP = (symbolS *) obstack_alloc (¬es, sizeof (symbolS)); 128 129 /* symbol must be born in some fixed state. This seems as good as any. */ 130 memset (symbolP, 0, sizeof (symbolS)); 131 132#ifdef BFD_ASSEMBLER 133 symbolP->bsym = bfd_make_empty_symbol (stdoutput); 134 if (symbolP->bsym == NULL) 135 as_perror ("%s", "bfd_make_empty_symbol"); 136 symbolP->bsym->udata.p = (PTR) symbolP; 137#endif 138 S_SET_NAME (symbolP, preserved_copy_of_name); 139 140 S_SET_SEGMENT (symbolP, segment); 141 S_SET_VALUE (symbolP, valu); 142 symbol_clear_list_pointers (symbolP); 143 144 symbolP->sy_frag = frag; 145#ifndef BFD_ASSEMBLER 146 symbolP->sy_number = ~0; 147 symbolP->sy_name_offset = (unsigned int) ~0; 148#endif 149 150 obj_symbol_new_hook (symbolP); 151 152#ifdef tc_symbol_new_hook 153 tc_symbol_new_hook (symbolP); 154#endif 155 156 return symbolP; 157} 158 159 160/* 161 * colon() 162 * 163 * We have just seen "<name>:". 164 * Creates a struct symbol unless it already exists. 165 * 166 * Gripes if we are redefining a symbol incompatibly (and ignores it). 167 * 168 */ 169symbolS * 170colon (sym_name) /* just seen "x:" - rattle symbols & frags */ 171 const char *sym_name; /* symbol name, as a cannonical string */ 172 /* We copy this string: OK to alter later. */ 173{ 174 register symbolS *symbolP; /* symbol we are working with */ 175 176 /* Sun local labels go out of scope whenever a non-local symbol is 177 defined. */ 178 if (LOCAL_LABELS_DOLLAR) 179 { 180 int local; 181 182#ifdef BFD_ASSEMBLER 183 local = bfd_is_local_label_name (stdoutput, sym_name); 184#else 185 local = LOCAL_LABEL (sym_name); 186#endif 187 188 if (! local) 189 dollar_label_clear (); 190 } 191 192#ifndef WORKING_DOT_WORD 193 if (new_broken_words) 194 { 195 struct broken_word *a; 196 int possible_bytes; 197 fragS *frag_tmp; 198 char *frag_opcode; 199 200 extern const int md_short_jump_size; 201 extern const int md_long_jump_size; 202 possible_bytes = (md_short_jump_size 203 + new_broken_words * md_long_jump_size); 204 205 frag_tmp = frag_now; 206 frag_opcode = frag_var (rs_broken_word, 207 possible_bytes, 208 possible_bytes, 209 (relax_substateT) 0, 210 (symbolS *) broken_words, 211 (offsetT) 0, 212 NULL); 213 214 /* We want to store the pointer to where to insert the jump table in the 215 fr_opcode of the rs_broken_word frag. This requires a little 216 hackery. */ 217 while (frag_tmp 218 && (frag_tmp->fr_type != rs_broken_word 219 || frag_tmp->fr_opcode)) 220 frag_tmp = frag_tmp->fr_next; 221 know (frag_tmp); 222 frag_tmp->fr_opcode = frag_opcode; 223 new_broken_words = 0; 224 225 for (a = broken_words; a && a->dispfrag == 0; a = a->next_broken_word) 226 a->dispfrag = frag_tmp; 227 } 228#endif /* WORKING_DOT_WORD */ 229 230 if ((symbolP = symbol_find (sym_name)) != 0) 231 { 232#ifdef RESOLVE_SYMBOL_REDEFINITION 233 if (RESOLVE_SYMBOL_REDEFINITION (symbolP)) 234 return symbolP; 235#endif 236 /* 237 * Now check for undefined symbols 238 */ 239 if (!S_IS_DEFINED (symbolP) || S_IS_COMMON (symbolP)) 240 { 241 if (S_GET_VALUE (symbolP) == 0) 242 { 243 symbolP->sy_frag = frag_now; 244#ifdef OBJ_VMS 245 S_SET_OTHER(symbolP, const_flag); 246#endif 247 S_SET_VALUE (symbolP, (valueT) frag_now_fix ()); 248 S_SET_SEGMENT (symbolP, now_seg); 249#ifdef N_UNDF 250 know (N_UNDF == 0); 251#endif /* if we have one, it better be zero. */ 252 253 } 254 else 255 { 256 /* 257 * There are still several cases to check: 258 * A .comm/.lcomm symbol being redefined as 259 * initialized data is OK 260 * A .comm/.lcomm symbol being redefined with 261 * a larger size is also OK 262 * 263 * This only used to be allowed on VMS gas, but Sun cc 264 * on the sparc also depends on it. 265 */ 266 267 if (((!S_IS_DEBUG (symbolP) 268 && (!S_IS_DEFINED (symbolP) || S_IS_COMMON (symbolP)) 269 && S_IS_EXTERNAL (symbolP)) 270 || S_GET_SEGMENT (symbolP) == bss_section) 271 && (now_seg == data_section 272 || now_seg == S_GET_SEGMENT (symbolP))) 273 { 274 /* 275 * Select which of the 2 cases this is 276 */ 277 if (now_seg != data_section) 278 { 279 /* 280 * New .comm for prev .comm symbol. 281 * If the new size is larger we just 282 * change its value. If the new size 283 * is smaller, we ignore this symbol 284 */ 285 if (S_GET_VALUE (symbolP) 286 < ((unsigned) frag_now_fix ())) 287 { 288 S_SET_VALUE (symbolP, (valueT) frag_now_fix ()); 289 } 290 } 291 else 292 { 293 /* It is a .comm/.lcomm being converted to initialized 294 data. */ 295 symbolP->sy_frag = frag_now; 296#ifdef OBJ_VMS 297 S_SET_OTHER(symbolP, const_flag); 298#endif 299 S_SET_VALUE (symbolP, (valueT) frag_now_fix ()); 300 S_SET_SEGMENT (symbolP, now_seg); /* keep N_EXT bit */ 301 } 302 } 303 else 304 { 305#if defined (S_GET_OTHER) && defined (S_GET_DESC) 306 as_fatal ("Symbol \"%s\" is already defined as \"%s\"/%d.%d.%ld.", 307 sym_name, 308 segment_name (S_GET_SEGMENT (symbolP)), 309 S_GET_OTHER (symbolP), S_GET_DESC (symbolP), 310 (long) S_GET_VALUE (symbolP)); 311#else 312 as_fatal ("Symbol \"%s\" is already defined as \"%s\"/%ld.", 313 sym_name, 314 segment_name (S_GET_SEGMENT (symbolP)), 315 (long) S_GET_VALUE (symbolP)); 316#endif 317 } 318 } /* if the undefined symbol has no value */ 319 } 320 else 321 { 322 /* Don't blow up if the definition is the same */ 323 if (!(frag_now == symbolP->sy_frag 324 && S_GET_VALUE (symbolP) == frag_now_fix () 325 && S_GET_SEGMENT (symbolP) == now_seg)) 326 as_fatal ("Symbol %s already defined.", sym_name); 327 } /* if this symbol is not yet defined */ 328 329 } 330 else 331 { 332 symbolP = symbol_new (sym_name, now_seg, (valueT) frag_now_fix (), 333 frag_now); 334#ifdef OBJ_VMS 335 S_SET_OTHER (symbolP, const_flag); 336#endif /* OBJ_VMS */ 337 338 symbol_table_insert (symbolP); 339 } /* if we have seen this symbol before */ 340 341 if (mri_common_symbol != NULL) 342 { 343 /* This symbol is actually being defined within an MRI common 344 section. This requires special handling. */ 345 symbolP->sy_value.X_op = O_symbol; 346 symbolP->sy_value.X_add_symbol = mri_common_symbol; 347 symbolP->sy_value.X_add_number = S_GET_VALUE (mri_common_symbol); 348 symbolP->sy_frag = &zero_address_frag; 349 S_SET_SEGMENT (symbolP, expr_section); 350 symbolP->sy_mri_common = 1; 351 } 352 353#ifdef tc_frob_label 354 tc_frob_label (symbolP); 355#endif 356#ifdef obj_frob_label 357 obj_frob_label (symbolP); 358#endif 359 360 return symbolP; 361} 362 363 364/* 365 * symbol_table_insert() 366 * 367 * Die if we can't insert the symbol. 368 * 369 */ 370 371void 372symbol_table_insert (symbolP) 373 symbolS *symbolP; 374{ 375 register const char *error_string; 376 377 know (symbolP); 378 know (S_GET_NAME (symbolP)); 379 380 if ((error_string = hash_jam (sy_hash, S_GET_NAME (symbolP), (PTR) symbolP))) 381 { 382 as_fatal ("Inserting \"%s\" into symbol table failed: %s", 383 S_GET_NAME (symbolP), error_string); 384 } /* on error */ 385} /* symbol_table_insert() */ 386 387/* 388 * symbol_find_or_make() 389 * 390 * If a symbol name does not exist, create it as undefined, and insert 391 * it into the symbol table. Return a pointer to it. 392 */ 393symbolS * 394symbol_find_or_make (name) 395 const char *name; 396{ 397 register symbolS *symbolP; 398 399 symbolP = symbol_find (name); 400 401 if (symbolP == NULL) 402 { 403 symbolP = symbol_make (name); 404 405 symbol_table_insert (symbolP); 406 } /* if symbol wasn't found */ 407 408 return (symbolP); 409} /* symbol_find_or_make() */ 410 411symbolS * 412symbol_make (name) 413 CONST char *name; 414{ 415 symbolS *symbolP; 416 417 /* Let the machine description default it, e.g. for register names. */ 418 symbolP = md_undefined_symbol ((char *) name); 419 420 if (!symbolP) 421 symbolP = symbol_new (name, undefined_section, (valueT) 0, &zero_address_frag); 422 423 return (symbolP); 424} /* symbol_make() */ 425 426/* 427 * symbol_find() 428 * 429 * Implement symbol table lookup. 430 * In: A symbol's name as a string: '\0' can't be part of a symbol name. 431 * Out: NULL if the name was not in the symbol table, else the address 432 * of a struct symbol associated with that name. 433 */ 434 435symbolS * 436symbol_find (name) 437 CONST char *name; 438{ 439#ifdef STRIP_UNDERSCORE 440 return (symbol_find_base (name, 1)); 441#else /* STRIP_UNDERSCORE */ 442 return (symbol_find_base (name, 0)); 443#endif /* STRIP_UNDERSCORE */ 444} /* symbol_find() */ 445 446symbolS * 447symbol_find_base (name, strip_underscore) 448 CONST char *name; 449 int strip_underscore; 450{ 451 if (strip_underscore && *name == '_') 452 name++; 453 454#ifdef tc_canonicalize_symbol_name 455 { 456 char *copy; 457 458 copy = (char *) alloca (strlen (name) + 1); 459 strcpy (copy, name); 460 name = tc_canonicalize_symbol_name (copy); 461 } 462#endif 463 464 if (! symbols_case_sensitive) 465 { 466 unsigned char *copy; 467 468 copy = (unsigned char *) alloca (strlen (name) + 1); 469 name = (const char *) copy; 470 for (; *copy != '\0'; copy++) 471 if (islower (*copy)) 472 *copy = toupper (*copy); 473 } 474 475 return ((symbolS *) hash_find (sy_hash, name)); 476} 477 478/* 479 * Once upon a time, symbols were kept in a singly linked list. At 480 * least coff needs to be able to rearrange them from time to time, for 481 * which a doubly linked list is much more convenient. Loic did these 482 * as macros which seemed dangerous to me so they're now functions. 483 * xoxorich. 484 */ 485 486/* Link symbol ADDME after symbol TARGET in the chain. */ 487void 488symbol_append (addme, target, rootPP, lastPP) 489 symbolS *addme; 490 symbolS *target; 491 symbolS **rootPP; 492 symbolS **lastPP; 493{ 494 if (target == NULL) 495 { 496 know (*rootPP == NULL); 497 know (*lastPP == NULL); 498 addme->sy_next = NULL; 499#ifdef SYMBOLS_NEED_BACKPOINTERS 500 addme->sy_previous = NULL; 501#endif 502 *rootPP = addme; 503 *lastPP = addme; 504 return; 505 } /* if the list is empty */ 506 507 if (target->sy_next != NULL) 508 { 509#ifdef SYMBOLS_NEED_BACKPOINTERS 510 target->sy_next->sy_previous = addme; 511#endif /* SYMBOLS_NEED_BACKPOINTERS */ 512 } 513 else 514 { 515 know (*lastPP == target); 516 *lastPP = addme; 517 } /* if we have a next */ 518 519 addme->sy_next = target->sy_next; 520 target->sy_next = addme; 521 522#ifdef SYMBOLS_NEED_BACKPOINTERS 523 addme->sy_previous = target; 524#endif /* SYMBOLS_NEED_BACKPOINTERS */ 525 526 debug_verify_symchain (symbol_rootP, symbol_lastP); 527} 528 529/* Set the chain pointers of SYMBOL to null. */ 530void 531symbol_clear_list_pointers (symbolP) 532 symbolS *symbolP; 533{ 534 symbolP->sy_next = NULL; 535#ifdef SYMBOLS_NEED_BACKPOINTERS 536 symbolP->sy_previous = NULL; 537#endif 538} 539 540#ifdef SYMBOLS_NEED_BACKPOINTERS 541/* Remove SYMBOLP from the list. */ 542void 543symbol_remove (symbolP, rootPP, lastPP) 544 symbolS *symbolP; 545 symbolS **rootPP; 546 symbolS **lastPP; 547{ 548 if (symbolP == *rootPP) 549 { 550 *rootPP = symbolP->sy_next; 551 } /* if it was the root */ 552 553 if (symbolP == *lastPP) 554 { 555 *lastPP = symbolP->sy_previous; 556 } /* if it was the tail */ 557 558 if (symbolP->sy_next != NULL) 559 { 560 symbolP->sy_next->sy_previous = symbolP->sy_previous; 561 } /* if not last */ 562 563 if (symbolP->sy_previous != NULL) 564 { 565 symbolP->sy_previous->sy_next = symbolP->sy_next; 566 } /* if not first */ 567 568 debug_verify_symchain (*rootPP, *lastPP); 569} 570 571/* Link symbol ADDME before symbol TARGET in the chain. */ 572void 573symbol_insert (addme, target, rootPP, lastPP) 574 symbolS *addme; 575 symbolS *target; 576 symbolS **rootPP; 577 symbolS **lastPP; 578{ 579 if (target->sy_previous != NULL) 580 { 581 target->sy_previous->sy_next = addme; 582 } 583 else 584 { 585 know (*rootPP == target); 586 *rootPP = addme; 587 } /* if not first */ 588 589 addme->sy_previous = target->sy_previous; 590 target->sy_previous = addme; 591 addme->sy_next = target; 592 593 debug_verify_symchain (*rootPP, *lastPP); 594} 595 596#endif /* SYMBOLS_NEED_BACKPOINTERS */ 597 598void 599verify_symbol_chain (rootP, lastP) 600 symbolS *rootP; 601 symbolS *lastP; 602{ 603 symbolS *symbolP = rootP; 604 605 if (symbolP == NULL) 606 return; 607 608 for (; symbol_next (symbolP) != NULL; symbolP = symbol_next (symbolP)) 609 { 610#ifdef SYMBOLS_NEED_BACKPOINTERS 611 assert (symbolP->sy_next->sy_previous == symbolP); 612#else 613 /* Walk the list anyways, to make sure pointers are still good. */ 614 ; 615#endif /* SYMBOLS_NEED_BACKPOINTERS */ 616 } 617 618 assert (lastP == symbolP); 619} 620 621void 622verify_symbol_chain_2 (sym) 623 symbolS *sym; 624{ 625 symbolS *p = sym, *n = sym; 626#ifdef SYMBOLS_NEED_BACKPOINTERS 627 while (symbol_previous (p)) 628 p = symbol_previous (p); 629#endif 630 while (symbol_next (n)) 631 n = symbol_next (n); 632 verify_symbol_chain (p, n); 633} 634 635/* Resolve the value of a symbol. This is called during the final 636 pass over the symbol table to resolve any symbols with complex 637 values. */ 638 639valueT 640resolve_symbol_value (symp, finalize) 641 symbolS *symp; 642 int finalize; 643{ 644 int resolved; 645 valueT final_val; 646 segT final_seg; 647 648 if (symp->sy_resolved) 649 { 650 if (symp->sy_value.X_op == O_constant) 651 return (valueT) symp->sy_value.X_add_number; 652 else 653 return 0; 654 } 655 656 resolved = 0; 657 final_seg = S_GET_SEGMENT (symp); 658 659 if (symp->sy_resolving) 660 { 661 if (finalize) 662 as_bad ("Symbol definition loop encountered at %s", S_GET_NAME (symp)); 663 final_val = 0; 664 resolved = 1; 665 } 666 else 667 { 668 symbolS *add_symbol, *op_symbol; 669 offsetT left, right; 670 segT seg_left, seg_right; 671 operatorT op; 672 673 symp->sy_resolving = 1; 674 675 /* Help out with CSE. */ 676 add_symbol = symp->sy_value.X_add_symbol; 677 op_symbol = symp->sy_value.X_op_symbol; 678 final_val = symp->sy_value.X_add_number; 679 op = symp->sy_value.X_op; 680 681 switch (op) 682 { 683 default: 684 BAD_CASE (op); 685 break; 686 687 case O_absent: 688 final_val = 0; 689 /* Fall through. */ 690 691 case O_constant: 692 final_val += symp->sy_frag->fr_address; 693 if (final_seg == expr_section) 694 final_seg = absolute_section; 695 resolved = 1; 696 break; 697 698 case O_symbol: 699 case O_symbol_rva: 700 left = resolve_symbol_value (add_symbol, finalize); 701 do_symbol: 702 703 if (symp->sy_mri_common) 704 { 705 /* This is a symbol inside an MRI common section. The 706 relocation routines are going to handle it specially. 707 Don't change the value. */ 708 resolved = add_symbol->sy_resolved; 709 break; 710 } 711 712 if (finalize && final_val == 0) 713 copy_symbol_attributes (symp, add_symbol); 714 715 /* If we have equated this symbol to an undefined symbol, we 716 keep X_op set to O_symbol, and we don't change 717 X_add_number. This permits the routine which writes out 718 relocation to detect this case, and convert the 719 relocation to be against the symbol to which this symbol 720 is equated. */ 721 if (! S_IS_DEFINED (add_symbol) || S_IS_COMMON (add_symbol)) 722 { 723 if (finalize) 724 { 725 symp->sy_value.X_op = O_symbol; 726 S_SET_SEGMENT (symp, S_GET_SEGMENT (add_symbol)); 727 symp->sy_value.X_add_number = final_val; 728 } 729 final_val = 0; 730 resolved = add_symbol->sy_resolved; 731 goto exit_dont_set_value; 732 } 733 else 734 { 735 final_val += symp->sy_frag->fr_address + left; 736 if (final_seg == expr_section || final_seg == undefined_section) 737 final_seg = S_GET_SEGMENT (add_symbol); 738 } 739 740 resolved = add_symbol->sy_resolved; 741 break; 742 743 case O_uminus: 744 case O_bit_not: 745 case O_logical_not: 746 left = resolve_symbol_value (add_symbol, finalize); 747 748 if (op == O_uminus) 749 left = -left; 750 else if (op == O_logical_not) 751 left = !left; 752 else 753 left = ~left; 754 755 final_val += left + symp->sy_frag->fr_address; 756 if (final_seg == expr_section || final_seg == undefined_section) 757 final_seg = absolute_section; 758 759 resolved = add_symbol->sy_resolved; 760 break; 761 762 case O_multiply: 763 case O_divide: 764 case O_modulus: 765 case O_left_shift: 766 case O_right_shift: 767 case O_bit_inclusive_or: 768 case O_bit_or_not: 769 case O_bit_exclusive_or: 770 case O_bit_and: 771 case O_add: 772 case O_subtract: 773 case O_eq: 774 case O_ne: 775 case O_lt: 776 case O_le: 777 case O_ge: 778 case O_gt: 779 case O_logical_and: 780 case O_logical_or: 781 left = resolve_symbol_value (add_symbol, finalize); 782 right = resolve_symbol_value (op_symbol, finalize); 783 seg_left = S_GET_SEGMENT (add_symbol); 784 seg_right = S_GET_SEGMENT (op_symbol); 785 786 /* Simplify addition or subtraction of a constant by folding the 787 constant into X_add_number. */ 788 if (op == O_add || op == O_subtract) 789 { 790 if (seg_right == absolute_section) 791 { 792 if (op == O_add) 793 final_val += right; 794 else 795 final_val -= right; 796 op = O_symbol; 797 op_symbol = NULL; 798 goto do_symbol; 799 } 800 else if (seg_left == absolute_section && op == O_add) 801 { 802 op = O_symbol; 803 final_val += left; 804 add_symbol = op_symbol; 805 left = right; 806 op_symbol = NULL; 807 goto do_symbol; 808 } 809 } 810 811 /* Subtraction is permitted if both operands are in the same 812 section. Otherwise, both operands must be absolute. We 813 already handled the case of addition or subtraction of a 814 constant above. This will probably need to be changed 815 for an object file format which supports arbitrary 816 expressions, such as IEEE-695. */ 817 /* Don't emit messages unless we're finalizing the symbol value, 818 otherwise we may get the same message multiple times. */ 819 if ((seg_left != absolute_section || seg_right != absolute_section) 820 && (op != O_subtract || seg_left != seg_right) 821 && finalize) 822 { 823 char *file; 824 unsigned int line; 825 826 if (expr_symbol_where (symp, &file, &line)) 827 { 828 if (seg_left == undefined_section) 829 as_bad_where (file, line, 830 "undefined symbol %s in operation", 831 S_GET_NAME (symp->sy_value.X_add_symbol)); 832 if (seg_right == undefined_section) 833 as_bad_where (file, line, 834 "undefined symbol %s in operation", 835 S_GET_NAME (symp->sy_value.X_op_symbol)); 836 if (seg_left != undefined_section 837 && seg_right != undefined_section) 838 as_bad_where (file, line, "invalid section for operation"); 839 } 840 else 841 { 842 if (seg_left == undefined_section) 843 as_bad ("undefined symbol %s in operation setting %s", 844 S_GET_NAME (symp->sy_value.X_add_symbol), 845 S_GET_NAME (symp)); 846 if (seg_right == undefined_section) 847 as_bad ("undefined symbol %s in operation setting %s", 848 S_GET_NAME (symp->sy_value.X_op_symbol), 849 S_GET_NAME (symp)); 850 if (seg_left != undefined_section 851 && seg_right != undefined_section) 852 as_bad ("invalid section for operation setting %s", 853 S_GET_NAME (symp)); 854 } 855 } 856 857 /* Check for division by zero. */ 858 if ((op == O_divide || op == O_modulus) && right == 0) 859 { 860 /* If seg_right is not absolute_section, then we've 861 already issued a warning about using a bad symbol. */ 862 if (seg_right == absolute_section && finalize) 863 { 864 char *file; 865 unsigned int line; 866 867 if (expr_symbol_where (symp, &file, &line)) 868 as_bad_where (file, line, "division by zero"); 869 else 870 as_bad ("division by zero when setting %s", 871 S_GET_NAME (symp)); 872 } 873 874 right = 1; 875 } 876 877 switch (symp->sy_value.X_op) 878 { 879 case O_multiply: left *= right; break; 880 case O_divide: left /= right; break; 881 case O_modulus: left %= right; break; 882 case O_left_shift: left <<= right; break; 883 case O_right_shift: left >>= right; break; 884 case O_bit_inclusive_or: left |= right; break; 885 case O_bit_or_not: left |= ~right; break; 886 case O_bit_exclusive_or: left ^= right; break; 887 case O_bit_and: left &= right; break; 888 case O_add: left += right; break; 889 case O_subtract: left -= right; break; 890 case O_eq: left = left == right ? ~ (offsetT) 0 : 0; break; 891 case O_ne: left = left != right ? ~ (offsetT) 0 : 0; break; 892 case O_lt: left = left < right ? ~ (offsetT) 0 : 0; break; 893 case O_le: left = left <= right ? ~ (offsetT) 0 : 0; break; 894 case O_ge: left = left >= right ? ~ (offsetT) 0 : 0; break; 895 case O_gt: left = left > right ? ~ (offsetT) 0 : 0; break; 896 case O_logical_and: left = left && right; break; 897 case O_logical_or: left = left || right; break; 898 default: abort (); 899 } 900 901 final_val += symp->sy_frag->fr_address + left; 902 if (final_seg == expr_section || final_seg == undefined_section) 903 final_seg = absolute_section; 904 resolved = (add_symbol->sy_resolved && op_symbol->sy_resolved); 905 break; 906 907 case O_register: 908 case O_big: 909 case O_illegal: 910 /* Give an error (below) if not in expr_section. We don't 911 want to worry about expr_section symbols, because they 912 are fictional (they are created as part of expression 913 resolution), and any problems may not actually mean 914 anything. */ 915 break; 916 } 917 918 symp->sy_resolving = 0; 919 } 920 921 if (finalize) 922 { 923 S_SET_VALUE (symp, final_val); 924 925#if defined (OBJ_AOUT) && ! defined (BFD_ASSEMBLER) 926 /* The old a.out backend does not handle S_SET_SEGMENT correctly 927 for a stab symbol, so we use this bad hack. */ 928 if (final_seg != S_GET_SEGMENT (symp)) 929#endif 930 S_SET_SEGMENT (symp, final_seg); 931 } 932 933exit_dont_set_value: 934 /* Don't worry if we can't resolve an expr_section symbol. */ 935 if (finalize) 936 { 937 if (resolved) 938 symp->sy_resolved = 1; 939 else if (S_GET_SEGMENT (symp) != expr_section) 940 { 941 as_bad ("can't resolve value for symbol \"%s\"", S_GET_NAME (symp)); 942 symp->sy_resolved = 1; 943 } 944 } 945 946 return final_val; 947} 948 949/* Dollar labels look like a number followed by a dollar sign. Eg, "42$". 950 They are *really* local. That is, they go out of scope whenever we see a 951 label that isn't local. Also, like fb labels, there can be multiple 952 instances of a dollar label. Therefor, we name encode each instance with 953 the instance number, keep a list of defined symbols separate from the real 954 symbol table, and we treat these buggers as a sparse array. */ 955 956static long *dollar_labels; 957static long *dollar_label_instances; 958static char *dollar_label_defines; 959static unsigned long dollar_label_count; 960static unsigned long dollar_label_max; 961 962int 963dollar_label_defined (label) 964 long label; 965{ 966 long *i; 967 968 know ((dollar_labels != NULL) || (dollar_label_count == 0)); 969 970 for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i) 971 if (*i == label) 972 return dollar_label_defines[i - dollar_labels]; 973 974 /* if we get here, label isn't defined */ 975 return 0; 976} /* dollar_label_defined() */ 977 978static long 979dollar_label_instance (label) 980 long label; 981{ 982 long *i; 983 984 know ((dollar_labels != NULL) || (dollar_label_count == 0)); 985 986 for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i) 987 if (*i == label) 988 return (dollar_label_instances[i - dollar_labels]); 989 990 /* If we get here, we haven't seen the label before, therefore its instance 991 count is zero. */ 992 return 0; 993} 994 995void 996dollar_label_clear () 997{ 998 memset (dollar_label_defines, '\0', (unsigned int) dollar_label_count); 999} 1000 1001#define DOLLAR_LABEL_BUMP_BY 10 1002 1003void 1004define_dollar_label (label) 1005 long label; 1006{ 1007 long *i; 1008 1009 for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i) 1010 if (*i == label) 1011 { 1012 ++dollar_label_instances[i - dollar_labels]; 1013 dollar_label_defines[i - dollar_labels] = 1; 1014 return; 1015 } 1016 1017 /* if we get to here, we don't have label listed yet. */ 1018 1019 if (dollar_labels == NULL) 1020 { 1021 dollar_labels = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long)); 1022 dollar_label_instances = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY * sizeof (long)); 1023 dollar_label_defines = xmalloc (DOLLAR_LABEL_BUMP_BY); 1024 dollar_label_max = DOLLAR_LABEL_BUMP_BY; 1025 dollar_label_count = 0; 1026 } 1027 else if (dollar_label_count == dollar_label_max) 1028 { 1029 dollar_label_max += DOLLAR_LABEL_BUMP_BY; 1030 dollar_labels = (long *) xrealloc ((char *) dollar_labels, 1031 dollar_label_max * sizeof (long)); 1032 dollar_label_instances = (long *) xrealloc ((char *) dollar_label_instances, 1033 dollar_label_max * sizeof (long)); 1034 dollar_label_defines = xrealloc (dollar_label_defines, dollar_label_max); 1035 } /* if we needed to grow */ 1036 1037 dollar_labels[dollar_label_count] = label; 1038 dollar_label_instances[dollar_label_count] = 1; 1039 dollar_label_defines[dollar_label_count] = 1; 1040 ++dollar_label_count; 1041} 1042 1043/* 1044 * dollar_label_name() 1045 * 1046 * Caller must copy returned name: we re-use the area for the next name. 1047 * 1048 * The mth occurence of label n: is turned into the symbol "Ln^Am" 1049 * where n is the label number and m is the instance number. "L" makes 1050 * it a label discarded unless debugging and "^A"('\1') ensures no 1051 * ordinary symbol SHOULD get the same name as a local label 1052 * symbol. The first "4:" is "L4^A1" - the m numbers begin at 1. 1053 * 1054 * fb labels get the same treatment, except that ^B is used in place of ^A. 1055 */ 1056 1057char * /* Return local label name. */ 1058dollar_label_name (n, augend) 1059 register long n; /* we just saw "n$:" : n a number */ 1060 register int augend; /* 0 for current instance, 1 for new instance */ 1061{ 1062 long i; 1063 /* Returned to caller, then copied. used for created names ("4f") */ 1064 static char symbol_name_build[24]; 1065 register char *p; 1066 register char *q; 1067 char symbol_name_temporary[20]; /* build up a number, BACKWARDS */ 1068 1069 know (n >= 0); 1070 know (augend == 0 || augend == 1); 1071 p = symbol_name_build; 1072 *p++ = 'L'; 1073 1074 /* Next code just does sprintf( {}, "%d", n); */ 1075 /* label number */ 1076 q = symbol_name_temporary; 1077 for (*q++ = 0, i = n; i; ++q) 1078 { 1079 *q = i % 10 + '0'; 1080 i /= 10; 1081 } 1082 while ((*p = *--q) != '\0') 1083 ++p; 1084 1085 *p++ = 1; /* ^A */ 1086 1087 /* instance number */ 1088 q = symbol_name_temporary; 1089 for (*q++ = 0, i = dollar_label_instance (n) + augend; i; ++q) 1090 { 1091 *q = i % 10 + '0'; 1092 i /= 10; 1093 } 1094 while ((*p++ = *--q) != '\0');; 1095 1096 /* The label, as a '\0' ended string, starts at symbol_name_build. */ 1097 return symbol_name_build; 1098} 1099 1100/* 1101 * Sombody else's idea of local labels. They are made by "n:" where n 1102 * is any decimal digit. Refer to them with 1103 * "nb" for previous (backward) n: 1104 * or "nf" for next (forward) n:. 1105 * 1106 * We do a little better and let n be any number, not just a single digit, but 1107 * since the other guy's assembler only does ten, we treat the first ten 1108 * specially. 1109 * 1110 * Like someone else's assembler, we have one set of local label counters for 1111 * entire assembly, not one set per (sub)segment like in most assemblers. This 1112 * implies that one can refer to a label in another segment, and indeed some 1113 * crufty compilers have done just that. 1114 * 1115 * Since there could be a LOT of these things, treat them as a sparse array. 1116 */ 1117 1118#define FB_LABEL_SPECIAL (10) 1119 1120static long fb_low_counter[FB_LABEL_SPECIAL]; 1121static long *fb_labels; 1122static long *fb_label_instances; 1123static long fb_label_count; 1124static long fb_label_max; 1125 1126/* this must be more than FB_LABEL_SPECIAL */ 1127#define FB_LABEL_BUMP_BY (FB_LABEL_SPECIAL + 6) 1128 1129static void 1130fb_label_init () 1131{ 1132 memset ((void *) fb_low_counter, '\0', sizeof (fb_low_counter)); 1133} /* fb_label_init() */ 1134 1135/* add one to the instance number of this fb label */ 1136void 1137fb_label_instance_inc (label) 1138 long label; 1139{ 1140 long *i; 1141 1142 if (label < FB_LABEL_SPECIAL) 1143 { 1144 ++fb_low_counter[label]; 1145 return; 1146 } 1147 1148 if (fb_labels != NULL) 1149 { 1150 for (i = fb_labels + FB_LABEL_SPECIAL; 1151 i < fb_labels + fb_label_count; ++i) 1152 { 1153 if (*i == label) 1154 { 1155 ++fb_label_instances[i - fb_labels]; 1156 return; 1157 } /* if we find it */ 1158 } /* for each existing label */ 1159 } 1160 1161 /* if we get to here, we don't have label listed yet. */ 1162 1163 if (fb_labels == NULL) 1164 { 1165 fb_labels = (long *) xmalloc (FB_LABEL_BUMP_BY * sizeof (long)); 1166 fb_label_instances = (long *) xmalloc (FB_LABEL_BUMP_BY * sizeof (long)); 1167 fb_label_max = FB_LABEL_BUMP_BY; 1168 fb_label_count = FB_LABEL_SPECIAL; 1169 1170 } 1171 else if (fb_label_count == fb_label_max) 1172 { 1173 fb_label_max += FB_LABEL_BUMP_BY; 1174 fb_labels = (long *) xrealloc ((char *) fb_labels, 1175 fb_label_max * sizeof (long)); 1176 fb_label_instances = (long *) xrealloc ((char *) fb_label_instances, 1177 fb_label_max * sizeof (long)); 1178 } /* if we needed to grow */ 1179 1180 fb_labels[fb_label_count] = label; 1181 fb_label_instances[fb_label_count] = 1; 1182 ++fb_label_count; 1183} 1184 1185static long 1186fb_label_instance (label) 1187 long label; 1188{ 1189 long *i; 1190 1191 if (label < FB_LABEL_SPECIAL) 1192 { 1193 return (fb_low_counter[label]); 1194 } 1195 1196 if (fb_labels != NULL) 1197 { 1198 for (i = fb_labels + FB_LABEL_SPECIAL; 1199 i < fb_labels + fb_label_count; ++i) 1200 { 1201 if (*i == label) 1202 { 1203 return (fb_label_instances[i - fb_labels]); 1204 } /* if we find it */ 1205 } /* for each existing label */ 1206 } 1207 1208 /* We didn't find the label, so this must be a reference to the 1209 first instance. */ 1210 return 0; 1211} 1212 1213/* 1214 * fb_label_name() 1215 * 1216 * Caller must copy returned name: we re-use the area for the next name. 1217 * 1218 * The mth occurence of label n: is turned into the symbol "Ln^Bm" 1219 * where n is the label number and m is the instance number. "L" makes 1220 * it a label discarded unless debugging and "^B"('\2') ensures no 1221 * ordinary symbol SHOULD get the same name as a local label 1222 * symbol. The first "4:" is "L4^B1" - the m numbers begin at 1. 1223 * 1224 * dollar labels get the same treatment, except that ^A is used in place of ^B. */ 1225 1226char * /* Return local label name. */ 1227fb_label_name (n, augend) 1228 long n; /* we just saw "n:", "nf" or "nb" : n a number */ 1229 long augend; /* 0 for nb, 1 for n:, nf */ 1230{ 1231 long i; 1232 /* Returned to caller, then copied. used for created names ("4f") */ 1233 static char symbol_name_build[24]; 1234 register char *p; 1235 register char *q; 1236 char symbol_name_temporary[20]; /* build up a number, BACKWARDS */ 1237 1238 know (n >= 0); 1239 know (augend == 0 || augend == 1); 1240 p = symbol_name_build; 1241 *p++ = 'L'; 1242 1243 /* Next code just does sprintf( {}, "%d", n); */ 1244 /* label number */ 1245 q = symbol_name_temporary; 1246 for (*q++ = 0, i = n; i; ++q) 1247 { 1248 *q = i % 10 + '0'; 1249 i /= 10; 1250 } 1251 while ((*p = *--q) != '\0') 1252 ++p; 1253 1254 *p++ = 2; /* ^B */ 1255 1256 /* instance number */ 1257 q = symbol_name_temporary; 1258 for (*q++ = 0, i = fb_label_instance (n) + augend; i; ++q) 1259 { 1260 *q = i % 10 + '0'; 1261 i /= 10; 1262 } 1263 while ((*p++ = *--q) != '\0');; 1264 1265 /* The label, as a '\0' ended string, starts at symbol_name_build. */ 1266 return (symbol_name_build); 1267} /* fb_label_name() */ 1268 1269/* 1270 * decode name that may have been generated by foo_label_name() above. If 1271 * the name wasn't generated by foo_label_name(), then return it unaltered. 1272 * This is used for error messages. 1273 */ 1274 1275char * 1276decode_local_label_name (s) 1277 char *s; 1278{ 1279 char *p; 1280 char *symbol_decode; 1281 int label_number; 1282 int instance_number; 1283 char *type; 1284 const char *message_format = "\"%d\" (instance number %d of a %s label)"; 1285 1286 if (s[0] != 'L') 1287 return s; 1288 1289 for (label_number = 0, p = s + 1; isdigit ((unsigned char) *p); ++p) 1290 label_number = (10 * label_number) + *p - '0'; 1291 1292 if (*p == 1) 1293 type = "dollar"; 1294 else if (*p == 2) 1295 type = "fb"; 1296 else 1297 return s; 1298 1299 for (instance_number = 0, p++; isdigit ((unsigned char) *p); ++p) 1300 instance_number = (10 * instance_number) + *p - '0'; 1301 1302 symbol_decode = obstack_alloc (¬es, strlen (message_format) + 30); 1303 sprintf (symbol_decode, message_format, label_number, instance_number, type); 1304 1305 return symbol_decode; 1306} 1307 1308/* Get the value of a symbol. */ 1309 1310valueT 1311S_GET_VALUE (s) 1312 symbolS *s; 1313{ 1314 if (!s->sy_resolved && s->sy_value.X_op != O_constant) 1315 resolve_symbol_value (s, 1); 1316 if (s->sy_value.X_op != O_constant) 1317 { 1318 static symbolS *recur; 1319 1320 /* FIXME: In non BFD assemblers, S_IS_DEFINED and S_IS_COMMON 1321 may call S_GET_VALUE. We use a static symbol to avoid the 1322 immediate recursion. */ 1323 if (recur == s) 1324 return (valueT) s->sy_value.X_add_number; 1325 recur = s; 1326 if (! s->sy_resolved 1327 || s->sy_value.X_op != O_symbol 1328 || (S_IS_DEFINED (s) && ! S_IS_COMMON (s))) 1329 as_bad ("Attempt to get value of unresolved symbol %s", 1330 S_GET_NAME (s)); 1331 recur = NULL; 1332 } 1333 return (valueT) s->sy_value.X_add_number; 1334} 1335 1336/* Set the value of a symbol. */ 1337 1338void 1339S_SET_VALUE (s, val) 1340 symbolS *s; 1341 valueT val; 1342{ 1343 s->sy_value.X_op = O_constant; 1344 s->sy_value.X_add_number = (offsetT) val; 1345 s->sy_value.X_unsigned = 0; 1346} 1347 1348void 1349copy_symbol_attributes (dest, src) 1350 symbolS *dest, *src; 1351{ 1352#ifdef BFD_ASSEMBLER 1353 /* In an expression, transfer the settings of these flags. 1354 The user can override later, of course. */ 1355#define COPIED_SYMFLAGS (BSF_FUNCTION | BSF_OBJECT) 1356 dest->bsym->flags |= src->bsym->flags & COPIED_SYMFLAGS; 1357#endif 1358 1359#ifdef OBJ_COPY_SYMBOL_ATTRIBUTES 1360 OBJ_COPY_SYMBOL_ATTRIBUTES (dest, src); 1361#endif 1362} 1363 1364#ifdef BFD_ASSEMBLER 1365 1366int 1367S_IS_EXTERNAL (s) 1368 symbolS *s; 1369{ 1370 flagword flags = s->bsym->flags; 1371 1372 /* sanity check */ 1373 if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL)) 1374 abort (); 1375 1376 return (flags & BSF_GLOBAL) != 0; 1377} 1378 1379int 1380S_IS_WEAK (s) 1381 symbolS *s; 1382{ 1383 return (s->bsym->flags & BSF_WEAK) != 0; 1384} 1385 1386int 1387S_IS_COMMON (s) 1388 symbolS *s; 1389{ 1390 return bfd_is_com_section (s->bsym->section); 1391} 1392 1393int 1394S_IS_DEFINED (s) 1395 symbolS *s; 1396{ 1397 return s->bsym->section != undefined_section; 1398} 1399 1400int 1401S_IS_DEBUG (s) 1402 symbolS *s; 1403{ 1404 if (s->bsym->flags & BSF_DEBUGGING) 1405 return 1; 1406 return 0; 1407} 1408 1409int 1410S_IS_LOCAL (s) 1411 symbolS *s; 1412{ 1413 flagword flags = s->bsym->flags; 1414 const char *name; 1415 1416 /* sanity check */ 1417 if ((flags & BSF_LOCAL) && (flags & BSF_GLOBAL)) 1418 abort (); 1419 1420 if (bfd_get_section (s->bsym) == reg_section) 1421 return 1; 1422 1423 if (flag_strip_local_absolute 1424 && (flags & BSF_GLOBAL) == 0 1425 && bfd_get_section (s->bsym) == absolute_section) 1426 return 1; 1427 1428 name = S_GET_NAME (s); 1429 return (name != NULL 1430 && ! S_IS_DEBUG (s) 1431 && (strchr (name, '\001') 1432 || strchr (name, '\002') 1433 || (! flag_keep_locals 1434 && (bfd_is_local_label (stdoutput, s->bsym) 1435 || (flag_mri 1436 && name[0] == '?' 1437 && name[1] == '?'))))); 1438} 1439 1440int 1441S_IS_EXTERN (s) 1442 symbolS *s; 1443{ 1444 return S_IS_EXTERNAL (s); 1445} 1446 1447int 1448S_IS_STABD (s) 1449 symbolS *s; 1450{ 1451 return S_GET_NAME (s) == 0; 1452} 1453 1454CONST char * 1455S_GET_NAME (s) 1456 symbolS *s; 1457{ 1458 return s->bsym->name; 1459} 1460 1461segT 1462S_GET_SEGMENT (s) 1463 symbolS *s; 1464{ 1465 return s->bsym->section; 1466} 1467 1468void 1469S_SET_SEGMENT (s, seg) 1470 symbolS *s; 1471 segT seg; 1472{ 1473 /* Don't reassign section symbols. The direct reason is to prevent seg 1474 faults assigning back to const global symbols such as *ABS*, but it 1475 shouldn't happen anyway. */ 1476 1477 if (s->bsym->flags & BSF_SECTION_SYM) 1478 { 1479 if (s->bsym->section != seg) 1480 abort(); 1481 } 1482 else 1483 s->bsym->section = seg; 1484} 1485 1486void 1487S_SET_EXTERNAL (s) 1488 symbolS *s; 1489{ 1490 if ((s->bsym->flags & BSF_WEAK) != 0) 1491 { 1492 /* Let .weak override .global. */ 1493 return; 1494 } 1495 s->bsym->flags |= BSF_GLOBAL; 1496 s->bsym->flags &= ~(BSF_LOCAL|BSF_WEAK); 1497} 1498 1499void 1500S_CLEAR_EXTERNAL (s) 1501 symbolS *s; 1502{ 1503 if ((s->bsym->flags & BSF_WEAK) != 0) 1504 { 1505 /* Let .weak override. */ 1506 return; 1507 } 1508 s->bsym->flags |= BSF_LOCAL; 1509 s->bsym->flags &= ~(BSF_GLOBAL|BSF_WEAK); 1510} 1511 1512void 1513S_SET_WEAK (s) 1514 symbolS *s; 1515{ 1516 s->bsym->flags |= BSF_WEAK; 1517 s->bsym->flags &= ~(BSF_GLOBAL|BSF_LOCAL); 1518} 1519 1520void 1521S_SET_NAME (s, name) 1522 symbolS *s; 1523 char *name; 1524{ 1525 s->bsym->name = name; 1526} 1527#endif /* BFD_ASSEMBLER */ 1528 1529void 1530symbol_begin () 1531{ 1532 symbol_lastP = NULL; 1533 symbol_rootP = NULL; /* In case we have 0 symbols (!!) */ 1534 sy_hash = hash_new (); 1535 1536 memset ((char *) (&abs_symbol), '\0', sizeof (abs_symbol)); 1537#ifdef BFD_ASSEMBLER 1538#if defined (EMIT_SECTION_SYMBOLS) || !defined (RELOC_REQUIRES_SYMBOL) 1539 abs_symbol.bsym = bfd_abs_section.symbol; 1540#endif 1541#else 1542 /* Can't initialise a union. Sigh. */ 1543 S_SET_SEGMENT (&abs_symbol, absolute_section); 1544#endif 1545 abs_symbol.sy_value.X_op = O_constant; 1546 abs_symbol.sy_frag = &zero_address_frag; 1547 1548 if (LOCAL_LABELS_FB) 1549 fb_label_init (); 1550} 1551 1552 1553int indent_level; 1554 1555#if 0 1556 1557static void 1558indent () 1559{ 1560 printf ("%*s", indent_level * 4, ""); 1561} 1562 1563#endif 1564 1565void 1566print_symbol_value_1 (file, sym) 1567 FILE *file; 1568 symbolS *sym; 1569{ 1570 const char *name = S_GET_NAME (sym); 1571 if (!name || !name[0]) 1572 name = "(unnamed)"; 1573 fprintf (file, "sym %lx %s", (unsigned long) sym, name); 1574 if (sym->sy_frag != &zero_address_frag) 1575 fprintf (file, " frag %lx", (long) sym->sy_frag); 1576 if (sym->written) 1577 fprintf (file, " written"); 1578 if (sym->sy_resolved) 1579 fprintf (file, " resolved"); 1580 else if (sym->sy_resolving) 1581 fprintf (file, " resolving"); 1582 if (sym->sy_used_in_reloc) 1583 fprintf (file, " used-in-reloc"); 1584 if (sym->sy_used) 1585 fprintf (file, " used"); 1586 if (S_IS_LOCAL (sym)) 1587 fprintf (file, " local"); 1588 if (S_IS_EXTERN (sym)) 1589 fprintf (file, " extern"); 1590 if (S_IS_DEBUG (sym)) 1591 fprintf (file, " debug"); 1592 if (S_IS_DEFINED (sym)) 1593 fprintf (file, " defined"); 1594 fprintf (file, " %s", segment_name (S_GET_SEGMENT (sym))); 1595 if (sym->sy_resolved) 1596 { 1597 segT s = S_GET_SEGMENT (sym); 1598 1599 if (s != undefined_section 1600 && s != expr_section) 1601 fprintf (file, " %lx", (long) S_GET_VALUE (sym)); 1602 } 1603 else if (indent_level < 8 && S_GET_SEGMENT (sym) != undefined_section) 1604 { 1605 indent_level++; 1606 fprintf (file, "\n%*s<", indent_level * 4, ""); 1607 print_expr_1 (file, &sym->sy_value); 1608 fprintf (file, ">"); 1609 indent_level--; 1610 } 1611 fflush (file); 1612} 1613 1614void 1615print_symbol_value (sym) 1616 symbolS *sym; 1617{ 1618 indent_level = 0; 1619 print_symbol_value_1 (stderr, sym); 1620 fprintf (stderr, "\n"); 1621} 1622 1623void 1624print_expr_1 (file, exp) 1625 FILE *file; 1626 expressionS *exp; 1627{ 1628 fprintf (file, "expr %lx ", (long) exp); 1629 switch (exp->X_op) 1630 { 1631 case O_illegal: 1632 fprintf (file, "illegal"); 1633 break; 1634 case O_absent: 1635 fprintf (file, "absent"); 1636 break; 1637 case O_constant: 1638 fprintf (file, "constant %lx", (long) exp->X_add_number); 1639 break; 1640 case O_symbol: 1641 indent_level++; 1642 fprintf (file, "symbol\n%*s<", indent_level * 4, ""); 1643 print_symbol_value_1 (file, exp->X_add_symbol); 1644 fprintf (file, ">"); 1645 maybe_print_addnum: 1646 if (exp->X_add_number) 1647 fprintf (file, "\n%*s%lx", indent_level * 4, "", 1648 (long) exp->X_add_number); 1649 indent_level--; 1650 break; 1651 case O_register: 1652 fprintf (file, "register #%d", (int) exp->X_add_number); 1653 break; 1654 case O_big: 1655 fprintf (file, "big"); 1656 break; 1657 case O_uminus: 1658 fprintf (file, "uminus -<"); 1659 indent_level++; 1660 print_symbol_value_1 (file, exp->X_add_symbol); 1661 fprintf (file, ">"); 1662 goto maybe_print_addnum; 1663 case O_bit_not: 1664 fprintf (file, "bit_not"); 1665 break; 1666 case O_multiply: 1667 fprintf (file, "multiply"); 1668 break; 1669 case O_divide: 1670 fprintf (file, "divide"); 1671 break; 1672 case O_modulus: 1673 fprintf (file, "modulus"); 1674 break; 1675 case O_left_shift: 1676 fprintf (file, "lshift"); 1677 break; 1678 case O_right_shift: 1679 fprintf (file, "rshift"); 1680 break; 1681 case O_bit_inclusive_or: 1682 fprintf (file, "bit_ior"); 1683 break; 1684 case O_bit_exclusive_or: 1685 fprintf (file, "bit_xor"); 1686 break; 1687 case O_bit_and: 1688 fprintf (file, "bit_and"); 1689 break; 1690 case O_eq: 1691 fprintf (file, "eq"); 1692 break; 1693 case O_ne: 1694 fprintf (file, "ne"); 1695 break; 1696 case O_lt: 1697 fprintf (file, "lt"); 1698 break; 1699 case O_le: 1700 fprintf (file, "le"); 1701 break; 1702 case O_ge: 1703 fprintf (file, "ge"); 1704 break; 1705 case O_gt: 1706 fprintf (file, "gt"); 1707 break; 1708 case O_logical_and: 1709 fprintf (file, "logical_and"); 1710 break; 1711 case O_logical_or: 1712 fprintf (file, "logical_or"); 1713 break; 1714 case O_add: 1715 indent_level++; 1716 fprintf (file, "add\n%*s<", indent_level * 4, ""); 1717 print_symbol_value_1 (file, exp->X_add_symbol); 1718 fprintf (file, ">\n%*s<", indent_level * 4, ""); 1719 print_symbol_value_1 (file, exp->X_op_symbol); 1720 fprintf (file, ">"); 1721 goto maybe_print_addnum; 1722 case O_subtract: 1723 indent_level++; 1724 fprintf (file, "subtract\n%*s<", indent_level * 4, ""); 1725 print_symbol_value_1 (file, exp->X_add_symbol); 1726 fprintf (file, ">\n%*s<", indent_level * 4, ""); 1727 print_symbol_value_1 (file, exp->X_op_symbol); 1728 fprintf (file, ">"); 1729 goto maybe_print_addnum; 1730 default: 1731 fprintf (file, "{unknown opcode %d}", (int) exp->X_op); 1732 break; 1733 } 1734 fflush (stdout); 1735} 1736 1737void 1738print_expr (exp) 1739 expressionS *exp; 1740{ 1741 print_expr_1 (stderr, exp); 1742 fprintf (stderr, "\n"); 1743} 1744 1745void 1746symbol_print_statistics (file) 1747 FILE *file; 1748{ 1749 hash_print_statistics (file, "symbol table", sy_hash); 1750} 1751 1752/* end of symbols.c */ 1753