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