obj-elf.c revision 77298
1/* ELF object file format 2 Copyright (C) 1992, 93, 94, 95, 96, 97, 98, 99, 2000 3 Free Software Foundation, Inc. 4 5 This file is part of GAS, the GNU Assembler. 6 7 GAS is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as 9 published by the Free Software Foundation; either version 2, 10 or (at your option) any later version. 11 12 GAS is distributed in the hope that it will be useful, but 13 WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See 15 the 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 OBJ_HEADER "obj-elf.h" 23#include "as.h" 24#include "subsegs.h" 25#include "obstack.h" 26 27#ifndef ECOFF_DEBUGGING 28#define ECOFF_DEBUGGING 0 29#else 30#define NEED_ECOFF_DEBUG 31#endif 32 33#ifdef NEED_ECOFF_DEBUG 34#include "ecoff.h" 35#endif 36 37#ifdef TC_ALPHA 38#include "elf/alpha.h" 39#endif 40 41#ifdef TC_MIPS 42#include "elf/mips.h" 43#endif 44 45#ifdef TC_PPC 46#include "elf/ppc.h" 47#endif 48 49#ifdef TC_I370 50#include "elf/i370.h" 51#endif 52 53static bfd_vma elf_s_get_size PARAMS ((symbolS *)); 54static void elf_s_set_size PARAMS ((symbolS *, bfd_vma)); 55static bfd_vma elf_s_get_align PARAMS ((symbolS *)); 56static void elf_s_set_align PARAMS ((symbolS *, bfd_vma)); 57static void elf_s_set_other PARAMS ((symbolS *, int)); 58static void elf_copy_symbol_attributes PARAMS ((symbolS *, symbolS *)); 59static int elf_sec_sym_ok_for_reloc PARAMS ((asection *)); 60static void adjust_stab_sections PARAMS ((bfd *, asection *, PTR)); 61static int elf_separate_stab_sections PARAMS ((void)); 62static void elf_init_stab_section PARAMS ((segT)); 63 64#ifdef NEED_ECOFF_DEBUG 65static boolean elf_get_extr PARAMS ((asymbol *, EXTR *)); 66static void elf_set_index PARAMS ((asymbol *, bfd_size_type)); 67#endif 68 69static void obj_elf_line PARAMS ((int)); 70void obj_elf_version PARAMS ((int)); 71static void obj_elf_size PARAMS ((int)); 72static void obj_elf_type PARAMS ((int)); 73static void obj_elf_ident PARAMS ((int)); 74static void obj_elf_weak PARAMS ((int)); 75static void obj_elf_local PARAMS ((int)); 76static void obj_elf_visibility PARAMS ((int)); 77static void obj_elf_symver PARAMS ((int)); 78static void obj_elf_subsection PARAMS ((int)); 79static void obj_elf_popsection PARAMS ((int)); 80 81static const pseudo_typeS elf_pseudo_table[] = 82{ 83 {"comm", obj_elf_common, 0}, 84 {"common", obj_elf_common, 1}, 85 {"ident", obj_elf_ident, 0}, 86 {"local", obj_elf_local, 0}, 87 {"previous", obj_elf_previous, 0}, 88 {"section", obj_elf_section, 0}, 89 {"section.s", obj_elf_section, 0}, 90 {"sect", obj_elf_section, 0}, 91 {"sect.s", obj_elf_section, 0}, 92 {"pushsection", obj_elf_section, 1}, 93 {"popsection", obj_elf_popsection, 0}, 94 {"size", obj_elf_size, 0}, 95 {"type", obj_elf_type, 0}, 96 {"version", obj_elf_version, 0}, 97 {"weak", obj_elf_weak, 0}, 98 99 /* These define symbol visibility. */ 100 {"internal", obj_elf_visibility, STV_INTERNAL}, 101 {"hidden", obj_elf_visibility, STV_HIDDEN}, 102 {"protected", obj_elf_visibility, STV_PROTECTED}, 103 104 /* These are used for stabs-in-elf configurations. */ 105 {"line", obj_elf_line, 0}, 106 107 /* This is a GNU extension to handle symbol versions. */ 108 {"symver", obj_elf_symver, 0}, 109 110 /* A GNU extension to change subsection only. */ 111 {"subsection", obj_elf_subsection, 0}, 112 113 /* These are GNU extensions to aid in garbage collecting C++ vtables. */ 114 {"vtable_inherit", (void (*) PARAMS ((int))) &obj_elf_vtable_inherit, 0}, 115 {"vtable_entry", (void (*) PARAMS ((int))) &obj_elf_vtable_entry, 0}, 116 117 /* These are used for dwarf. */ 118 {"2byte", cons, 2}, 119 {"4byte", cons, 4}, 120 {"8byte", cons, 8}, 121 122 /* We need to trap the section changing calls to handle .previous. */ 123 {"data", obj_elf_data, 0}, 124 {"text", obj_elf_text, 0}, 125 126 /* End sentinel. */ 127 {NULL, NULL, 0}, 128}; 129 130static const pseudo_typeS ecoff_debug_pseudo_table[] = 131{ 132#ifdef NEED_ECOFF_DEBUG 133 /* COFF style debugging information for ECOFF. .ln is not used; .loc 134 is used instead. */ 135 { "def", ecoff_directive_def, 0 }, 136 { "dim", ecoff_directive_dim, 0 }, 137 { "endef", ecoff_directive_endef, 0 }, 138 { "file", ecoff_directive_file, 0 }, 139 { "scl", ecoff_directive_scl, 0 }, 140 { "tag", ecoff_directive_tag, 0 }, 141 { "val", ecoff_directive_val, 0 }, 142 143 /* COFF debugging requires pseudo-ops .size and .type, but ELF 144 already has meanings for those. We use .esize and .etype 145 instead. These are only generated by gcc anyhow. */ 146 { "esize", ecoff_directive_size, 0 }, 147 { "etype", ecoff_directive_type, 0 }, 148 149 /* ECOFF specific debugging information. */ 150 { "begin", ecoff_directive_begin, 0 }, 151 { "bend", ecoff_directive_bend, 0 }, 152 { "end", ecoff_directive_end, 0 }, 153 { "ent", ecoff_directive_ent, 0 }, 154 { "fmask", ecoff_directive_fmask, 0 }, 155 { "frame", ecoff_directive_frame, 0 }, 156 { "loc", ecoff_directive_loc, 0 }, 157 { "mask", ecoff_directive_mask, 0 }, 158 159 /* Other ECOFF directives. */ 160 { "extern", ecoff_directive_extern, 0 }, 161 162 /* These are used on Irix. I don't know how to implement them. */ 163 { "alias", s_ignore, 0 }, 164 { "bgnb", s_ignore, 0 }, 165 { "endb", s_ignore, 0 }, 166 { "lab", s_ignore, 0 }, 167 { "noalias", s_ignore, 0 }, 168 { "verstamp", s_ignore, 0 }, 169 { "vreg", s_ignore, 0 }, 170#endif 171 172 {NULL, NULL, 0} /* end sentinel */ 173}; 174 175#undef NO_RELOC 176#include "aout/aout64.h" 177 178/* This is called when the assembler starts. */ 179 180void 181elf_begin () 182{ 183 /* Add symbols for the known sections to the symbol table. */ 184 symbol_table_insert (section_symbol (bfd_get_section_by_name (stdoutput, 185 TEXT_SECTION_NAME))); 186 symbol_table_insert (section_symbol (bfd_get_section_by_name (stdoutput, 187 DATA_SECTION_NAME))); 188 symbol_table_insert (section_symbol (bfd_get_section_by_name (stdoutput, 189 BSS_SECTION_NAME))); 190} 191 192void 193elf_pop_insert () 194{ 195 pop_insert (elf_pseudo_table); 196 if (ECOFF_DEBUGGING) 197 pop_insert (ecoff_debug_pseudo_table); 198} 199 200static bfd_vma 201elf_s_get_size (sym) 202 symbolS *sym; 203{ 204 return S_GET_SIZE (sym); 205} 206 207static void 208elf_s_set_size (sym, sz) 209 symbolS *sym; 210 bfd_vma sz; 211{ 212 S_SET_SIZE (sym, sz); 213} 214 215static bfd_vma 216elf_s_get_align (sym) 217 symbolS *sym; 218{ 219 return S_GET_ALIGN (sym); 220} 221 222static void 223elf_s_set_align (sym, align) 224 symbolS *sym; 225 bfd_vma align; 226{ 227 S_SET_ALIGN (sym, align); 228} 229 230int 231elf_s_get_other (sym) 232 symbolS *sym; 233{ 234 return elf_symbol (symbol_get_bfdsym (sym))->internal_elf_sym.st_other; 235} 236 237static void 238elf_s_set_other (sym, other) 239 symbolS *sym; 240 int other; 241{ 242 S_SET_OTHER (sym, other); 243} 244 245static void 246elf_copy_symbol_attributes (dest, src) 247 symbolS *dest, *src; 248{ 249 OBJ_COPY_SYMBOL_ATTRIBUTES (dest, src); 250} 251 252static int 253elf_sec_sym_ok_for_reloc (sec) 254 asection *sec; 255{ 256 return obj_sec_sym_ok_for_reloc (sec); 257} 258 259void 260elf_file_symbol (s) 261 const char *s; 262{ 263 symbolS *sym; 264 265 sym = symbol_new (s, absolute_section, (valueT) 0, (struct frag *) 0); 266 symbol_set_frag (sym, &zero_address_frag); 267 symbol_get_bfdsym (sym)->flags |= BSF_FILE; 268 269 if (symbol_rootP != sym) 270 { 271 symbol_remove (sym, &symbol_rootP, &symbol_lastP); 272 symbol_insert (sym, symbol_rootP, &symbol_rootP, &symbol_lastP); 273#ifdef DEBUG 274 verify_symbol_chain (symbol_rootP, symbol_lastP); 275#endif 276 } 277 278#ifdef NEED_ECOFF_DEBUG 279 ecoff_new_file (s); 280#endif 281} 282 283void 284obj_elf_common (is_common) 285 int is_common; 286{ 287 char *name; 288 char c; 289 char *p; 290 int temp, size; 291 symbolS *symbolP; 292 int have_align; 293 294 if (flag_mri && is_common) 295 { 296 s_mri_common (0); 297 return; 298 } 299 300 name = input_line_pointer; 301 c = get_symbol_end (); 302 /* just after name is now '\0' */ 303 p = input_line_pointer; 304 *p = c; 305 SKIP_WHITESPACE (); 306 if (*input_line_pointer != ',') 307 { 308 as_bad (_("Expected comma after symbol-name")); 309 ignore_rest_of_line (); 310 return; 311 } 312 input_line_pointer++; /* skip ',' */ 313 if ((temp = get_absolute_expression ()) < 0) 314 { 315 as_bad (_(".COMMon length (%d.) <0! Ignored."), temp); 316 ignore_rest_of_line (); 317 return; 318 } 319 size = temp; 320 *p = 0; 321 symbolP = symbol_find_or_make (name); 322 *p = c; 323 if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP)) 324 { 325 as_bad (_("Ignoring attempt to re-define symbol")); 326 ignore_rest_of_line (); 327 return; 328 } 329 if (S_GET_VALUE (symbolP) != 0) 330 { 331 if (S_GET_VALUE (symbolP) != (valueT) size) 332 { 333 as_warn (_("Length of .comm \"%s\" is already %ld. Not changed to %d."), 334 S_GET_NAME (symbolP), (long) S_GET_VALUE (symbolP), size); 335 } 336 } 337 know (symbolP->sy_frag == &zero_address_frag); 338 if (*input_line_pointer != ',') 339 have_align = 0; 340 else 341 { 342 have_align = 1; 343 input_line_pointer++; 344 SKIP_WHITESPACE (); 345 } 346 if (! have_align || *input_line_pointer != '"') 347 { 348 if (! have_align) 349 temp = 0; 350 else 351 { 352 temp = get_absolute_expression (); 353 if (temp < 0) 354 { 355 temp = 0; 356 as_warn (_("Common alignment negative; 0 assumed")); 357 } 358 } 359 if (symbol_get_obj (symbolP)->local) 360 { 361 segT old_sec; 362 int old_subsec; 363 char *pfrag; 364 int align; 365 366 /* allocate_bss: */ 367 old_sec = now_seg; 368 old_subsec = now_subseg; 369 if (temp) 370 { 371 /* convert to a power of 2 alignment */ 372 for (align = 0; (temp & 1) == 0; temp >>= 1, ++align); 373 if (temp != 1) 374 { 375 as_bad (_("Common alignment not a power of 2")); 376 ignore_rest_of_line (); 377 return; 378 } 379 } 380 else 381 align = 0; 382 record_alignment (bss_section, align); 383 subseg_set (bss_section, 0); 384 if (align) 385 frag_align (align, 0, 0); 386 if (S_GET_SEGMENT (symbolP) == bss_section) 387 symbol_get_frag (symbolP)->fr_symbol = 0; 388 symbol_set_frag (symbolP, frag_now); 389 pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP, 390 (offsetT) size, (char *) 0); 391 *pfrag = 0; 392 S_SET_SIZE (symbolP, size); 393 S_SET_SEGMENT (symbolP, bss_section); 394 S_CLEAR_EXTERNAL (symbolP); 395 subseg_set (old_sec, old_subsec); 396 } 397 else 398 { 399 allocate_common: 400 S_SET_VALUE (symbolP, (valueT) size); 401 S_SET_ALIGN (symbolP, temp); 402 S_SET_EXTERNAL (symbolP); 403 S_SET_SEGMENT (symbolP, bfd_com_section_ptr); 404 } 405 } 406 else 407 { 408 input_line_pointer++; 409 /* @@ Some use the dot, some don't. Can we get some consistency?? */ 410 if (*input_line_pointer == '.') 411 input_line_pointer++; 412 /* @@ Some say data, some say bss. */ 413 if (strncmp (input_line_pointer, "bss\"", 4) 414 && strncmp (input_line_pointer, "data\"", 5)) 415 { 416 while (*--input_line_pointer != '"') 417 ; 418 input_line_pointer--; 419 goto bad_common_segment; 420 } 421 while (*input_line_pointer++ != '"') 422 ; 423 goto allocate_common; 424 } 425 426 symbol_get_bfdsym (symbolP)->flags |= BSF_OBJECT; 427 428 demand_empty_rest_of_line (); 429 return; 430 431 { 432 bad_common_segment: 433 p = input_line_pointer; 434 while (*p && *p != '\n') 435 p++; 436 c = *p; 437 *p = '\0'; 438 as_bad (_("bad .common segment %s"), input_line_pointer + 1); 439 *p = c; 440 input_line_pointer = p; 441 ignore_rest_of_line (); 442 return; 443 } 444} 445 446static void 447obj_elf_local (ignore) 448 int ignore ATTRIBUTE_UNUSED; 449{ 450 char *name; 451 int c; 452 symbolS *symbolP; 453 454 do 455 { 456 name = input_line_pointer; 457 c = get_symbol_end (); 458 symbolP = symbol_find_or_make (name); 459 *input_line_pointer = c; 460 SKIP_WHITESPACE (); 461 S_CLEAR_EXTERNAL (symbolP); 462 symbol_get_obj (symbolP)->local = 1; 463 if (c == ',') 464 { 465 input_line_pointer++; 466 SKIP_WHITESPACE (); 467 if (*input_line_pointer == '\n') 468 c = '\n'; 469 } 470 } 471 while (c == ','); 472 demand_empty_rest_of_line (); 473} 474 475static void 476obj_elf_weak (ignore) 477 int ignore ATTRIBUTE_UNUSED; 478{ 479 char *name; 480 int c; 481 symbolS *symbolP; 482 483 do 484 { 485 name = input_line_pointer; 486 c = get_symbol_end (); 487 symbolP = symbol_find_or_make (name); 488 *input_line_pointer = c; 489 SKIP_WHITESPACE (); 490 S_SET_WEAK (symbolP); 491 symbol_get_obj (symbolP)->local = 1; 492 if (c == ',') 493 { 494 input_line_pointer++; 495 SKIP_WHITESPACE (); 496 if (*input_line_pointer == '\n') 497 c = '\n'; 498 } 499 } 500 while (c == ','); 501 demand_empty_rest_of_line (); 502} 503 504static void 505obj_elf_visibility (visibility) 506 int visibility; 507{ 508 char *name; 509 int c; 510 symbolS *symbolP; 511 asymbol *bfdsym; 512 elf_symbol_type *elfsym; 513 514 do 515 { 516 name = input_line_pointer; 517 c = get_symbol_end (); 518 symbolP = symbol_find_or_make (name); 519 *input_line_pointer = c; 520 521 SKIP_WHITESPACE (); 522 523 bfdsym = symbol_get_bfdsym (symbolP); 524 elfsym = elf_symbol_from (bfd_asymbol_bfd (bfdsym), bfdsym); 525 526 assert (elfsym); 527 528 elfsym->internal_elf_sym.st_other = visibility; 529 530 if (c == ',') 531 { 532 input_line_pointer ++; 533 534 SKIP_WHITESPACE (); 535 536 if (*input_line_pointer == '\n') 537 c = '\n'; 538 } 539 } 540 while (c == ','); 541 542 demand_empty_rest_of_line (); 543} 544 545static segT previous_section; 546static int previous_subsection; 547 548struct section_stack 549{ 550 struct section_stack *next; 551 segT seg, prev_seg; 552 int subseg, prev_subseg; 553}; 554 555static struct section_stack *section_stack; 556 557/* Handle the .section pseudo-op. This code supports two different 558 syntaxes. 559 560 The first is found on Solaris, and looks like 561 .section ".sec1",#alloc,#execinstr,#write 562 Here the names after '#' are the SHF_* flags to turn on for the 563 section. I'm not sure how it determines the SHT_* type (BFD 564 doesn't really give us control over the type, anyhow). 565 566 The second format is found on UnixWare, and probably most SVR4 567 machines, and looks like 568 .section .sec1,"a",@progbits 569 The quoted string may contain any combination of a, w, x, and 570 represents the SHF_* flags to turn on for the section. The string 571 beginning with '@' can be progbits or nobits. There should be 572 other possibilities, but I don't know what they are. In any case, 573 BFD doesn't really let us set the section type. */ 574 575/* Certain named sections have particular defined types, listed on p. 576 4-19 of the ABI. */ 577struct special_section 578{ 579 const char *name; 580 int type; 581 int attributes; 582}; 583 584static struct special_section const special_sections[] = 585{ 586 { ".bss", SHT_NOBITS, SHF_ALLOC + SHF_WRITE }, 587 { ".comment", SHT_PROGBITS, 0 }, 588 { ".data", SHT_PROGBITS, SHF_ALLOC + SHF_WRITE }, 589 { ".data1", SHT_PROGBITS, SHF_ALLOC + SHF_WRITE }, 590 { ".debug", SHT_PROGBITS, 0 }, 591 { ".fini", SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR }, 592 { ".init", SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR }, 593 { ".line", SHT_PROGBITS, 0 }, 594 { ".note", SHT_NOTE, 0 }, 595 { ".rodata", SHT_PROGBITS, SHF_ALLOC }, 596 { ".rodata1", SHT_PROGBITS, SHF_ALLOC }, 597 { ".text", SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR }, 598 599#ifdef ELF_TC_SPECIAL_SECTIONS 600 ELF_TC_SPECIAL_SECTIONS 601#endif 602 603#if 0 604 /* The following section names are special, but they can not 605 reasonably appear in assembler code. Some of the attributes are 606 processor dependent. */ 607 { ".dynamic", SHT_DYNAMIC, SHF_ALLOC /* + SHF_WRITE */ }, 608 { ".dynstr", SHT_STRTAB, SHF_ALLOC }, 609 { ".dynsym", SHT_DYNSYM, SHF_ALLOC }, 610 { ".got", SHT_PROGBITS, 0 }, 611 { ".hash", SHT_HASH, SHF_ALLOC }, 612 { ".interp", SHT_PROGBITS, /* SHF_ALLOC */ }, 613 { ".plt", SHT_PROGBITS, 0 }, 614 { ".shstrtab",SHT_STRTAB, 0 }, 615 { ".strtab", SHT_STRTAB, /* SHF_ALLOC */ }, 616 { ".symtab", SHT_SYMTAB, /* SHF_ALLOC */ }, 617#endif 618 619 { NULL, 0, 0 } 620}; 621 622void 623obj_elf_change_section (name, type, attr, push) 624 char *name; 625 int type, attr, push; 626{ 627 asection *old_sec; 628 segT sec; 629 flagword flags; 630 int i; 631 632#ifdef md_flush_pending_output 633 md_flush_pending_output (); 634#endif 635 636 /* Switch to the section, creating it if necessary. */ 637 if (push) 638 { 639 struct section_stack *elt; 640 elt = xmalloc (sizeof (struct section_stack)); 641 elt->next = section_stack; 642 elt->seg = now_seg; 643 elt->prev_seg = previous_section; 644 elt->subseg = now_subseg; 645 elt->prev_subseg = previous_subsection; 646 section_stack = elt; 647 } 648 previous_section = now_seg; 649 previous_subsection = now_subseg; 650 651 old_sec = bfd_get_section_by_name (stdoutput, name); 652 sec = subseg_new (name, 0); 653 654 /* See if this is one of the special sections. */ 655 for (i = 0; special_sections[i].name != NULL; i++) 656 if (strcmp (name, special_sections[i].name) == 0) 657 { 658 if (type == SHT_NULL) 659 type = special_sections[i].type; 660 else if (type != special_sections[i].type) 661 { 662 if (old_sec == NULL) 663 { 664 as_warn (_("Setting incorrect section type for %s"), name); 665 } 666 else 667 { 668 as_warn (_("Ignoring incorrect section type for %s"), name); 669 type = special_sections[i].type; 670 } 671 } 672 if ((attr &~ special_sections[i].attributes) != 0 673 && old_sec == NULL) 674 { 675 /* As a GNU extension, we permit a .note section to be 676 allocatable. If the linker sees an allocateable .note 677 section, it will create a PT_NOTE segment in the output 678 file. */ 679 if (strcmp (name, ".note") != 0 680 || attr != SHF_ALLOC) 681 as_warn (_("Setting incorrect section attributes for %s"), 682 name); 683 } 684 attr |= special_sections[i].attributes; 685 break; 686 } 687 688 /* Convert ELF type and flags to BFD flags. */ 689 flags = (SEC_RELOC 690 | ((attr & SHF_WRITE) ? 0 : SEC_READONLY) 691 | ((attr & SHF_ALLOC) ? SEC_ALLOC : 0) 692 | (((attr & SHF_ALLOC) && type != SHT_NOBITS) ? SEC_LOAD : 0) 693 | ((attr & SHF_EXECINSTR) ? SEC_CODE : 0)); 694#ifdef md_elf_section_flags 695 flags = md_elf_section_flags (flags, attr, type); 696#endif 697 698 if (old_sec == NULL) 699 { 700 symbolS *secsym; 701 702 /* Prevent SEC_HAS_CONTENTS from being inadvertently set. */ 703 if (type == SHT_NOBITS) 704 seg_info (sec)->bss = 1; 705 706 bfd_set_section_flags (stdoutput, sec, flags); 707 708 /* Add a symbol for this section to the symbol table. */ 709 secsym = symbol_find (name); 710 if (secsym != NULL) 711 symbol_set_bfdsym (secsym, sec->symbol); 712 else 713 symbol_table_insert (section_symbol (sec)); 714 } 715 else if (attr != 0) 716 { 717 /* If section attributes are specified the second time we see a 718 particular section, then check that they are the same as we 719 saw the first time. */ 720 if ((old_sec->flags ^ flags) 721 & (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE 722 | SEC_EXCLUDE | SEC_SORT_ENTRIES)) 723 as_warn (_("Ignoring changed section attributes for %s"), name); 724 } 725 726#ifdef md_elf_section_change_hook 727 md_elf_section_change_hook (); 728#endif 729} 730 731int 732obj_elf_parse_section_letters (str, len) 733 char *str; 734 size_t len; 735{ 736 int attr = 0; 737 738 while (len > 0) 739 { 740 switch (*str) 741 { 742 case 'a': 743 attr |= SHF_ALLOC; 744 break; 745 case 'w': 746 attr |= SHF_WRITE; 747 break; 748 case 'x': 749 attr |= SHF_EXECINSTR; 750 break; 751 default: 752 { 753 char *bad_msg = _("Unrecognized .section attribute: want a,w,x"); 754#ifdef md_elf_section_letter 755 int md_attr = md_elf_section_letter (*str, &bad_msg); 756 if (md_attr >= 0) 757 attr |= md_attr; 758 else 759#endif 760 { 761 as_warn ("%s", bad_msg); 762 attr = -1; 763 } 764 } 765 break; 766 } 767 str++, len--; 768 } 769 770 return attr; 771} 772 773int 774obj_elf_section_word (str, len) 775 char *str; 776 size_t len; 777{ 778 if (len == 5 && strncmp (str, "write", 5) == 0) 779 return SHF_WRITE; 780 if (len == 5 && strncmp (str, "alloc", 5) == 0) 781 return SHF_ALLOC; 782 if (len == 9 && strncmp (str, "execinstr", 9) == 0) 783 return SHF_EXECINSTR; 784 785#ifdef md_elf_section_word 786 { 787 int md_attr = md_elf_section_word (str, len); 788 if (md_attr >= 0) 789 return md_attr; 790 } 791#endif 792 793 as_warn (_("Unrecognized section attribute")); 794 return 0; 795} 796 797int 798obj_elf_section_type (str, len) 799 char *str; 800 size_t len; 801{ 802 if (len == 8 && strncmp (str, "progbits", 8) == 0) 803 return SHT_PROGBITS; 804 if (len == 6 && strncmp (str, "nobits", 6) == 0) 805 return SHT_NOBITS; 806 807#ifdef md_elf_section_type 808 { 809 int md_type = md_elf_section_type (str, len); 810 if (md_type >= 0) 811 return md_type; 812 } 813#endif 814 815 as_warn (_("Unrecognized section type")); 816 return 0; 817} 818 819void 820obj_elf_section (push) 821 int push; 822{ 823 char *name, *beg, *end; 824 int type, attr, dummy; 825 826#ifndef TC_I370 827 if (flag_mri) 828 { 829 char mri_type; 830 831#ifdef md_flush_pending_output 832 md_flush_pending_output (); 833#endif 834 835 previous_section = now_seg; 836 previous_subsection = now_subseg; 837 838 s_mri_sect (&mri_type); 839 840#ifdef md_elf_section_change_hook 841 md_elf_section_change_hook (); 842#endif 843 844 return; 845 } 846#endif /* ! defined (TC_I370) */ 847 848 /* Get name of section. */ 849 SKIP_WHITESPACE (); 850 if (*input_line_pointer == '"') 851 { 852 name = demand_copy_C_string (&dummy); 853 if (name == NULL) 854 { 855 ignore_rest_of_line (); 856 return; 857 } 858 } 859 else 860 { 861 end = input_line_pointer; 862 while (0 == strchr ("\n\t,; ", *end)) 863 end++; 864 if (end == input_line_pointer) 865 { 866 as_warn (_("Missing section name")); 867 ignore_rest_of_line (); 868 return; 869 } 870 871 name = xmalloc (end - input_line_pointer + 1); 872 memcpy (name, input_line_pointer, end - input_line_pointer); 873 name[end - input_line_pointer] = '\0'; 874 input_line_pointer = end; 875 } 876 SKIP_WHITESPACE (); 877 878 type = SHT_NULL; 879 attr = 0; 880 881 if (*input_line_pointer == ',') 882 { 883 /* Skip the comma. */ 884 ++input_line_pointer; 885 SKIP_WHITESPACE (); 886 887 if (*input_line_pointer == '"') 888 { 889 beg = demand_copy_C_string (&dummy); 890 if (beg == NULL) 891 { 892 ignore_rest_of_line (); 893 return; 894 } 895 attr |= obj_elf_parse_section_letters (beg, strlen (beg)); 896 897 SKIP_WHITESPACE (); 898 if (*input_line_pointer == ',') 899 { 900 char c; 901 ++input_line_pointer; 902 SKIP_WHITESPACE (); 903 c = *input_line_pointer; 904 if (c == '"') 905 { 906 beg = demand_copy_C_string (&dummy); 907 if (beg == NULL) 908 { 909 ignore_rest_of_line (); 910 return; 911 } 912 type = obj_elf_section_type (beg, strlen (beg)); 913 } 914 else if (c == '@' || c == '%') 915 { 916 beg = ++input_line_pointer; 917 c = get_symbol_end (); 918 *input_line_pointer = c; 919 type = obj_elf_section_type (beg, input_line_pointer - beg); 920 } 921 } 922 } 923 else 924 { 925 do 926 { 927 char c; 928 929 SKIP_WHITESPACE (); 930 if (*input_line_pointer != '#') 931 { 932 as_warn (_("Bad .section directive - character following name is not '#'")); 933 ignore_rest_of_line (); 934 return; 935 } 936 beg = ++input_line_pointer; 937 c = get_symbol_end (); 938 *input_line_pointer = c; 939 940 attr |= obj_elf_section_word (beg, input_line_pointer - beg); 941 942 SKIP_WHITESPACE (); 943 } 944 while (*input_line_pointer++ == ','); 945 --input_line_pointer; 946 } 947 } 948 949 demand_empty_rest_of_line (); 950 951 obj_elf_change_section (name, type, attr, push); 952} 953 954/* Change to the .data section. */ 955 956void 957obj_elf_data (i) 958 int i; 959{ 960#ifdef md_flush_pending_output 961 md_flush_pending_output (); 962#endif 963 964 previous_section = now_seg; 965 previous_subsection = now_subseg; 966 s_data (i); 967 968#ifdef md_elf_section_change_hook 969 md_elf_section_change_hook (); 970#endif 971} 972 973/* Change to the .text section. */ 974 975void 976obj_elf_text (i) 977 int i; 978{ 979#ifdef md_flush_pending_output 980 md_flush_pending_output (); 981#endif 982 983 previous_section = now_seg; 984 previous_subsection = now_subseg; 985 s_text (i); 986 987#ifdef md_elf_section_change_hook 988 md_elf_section_change_hook (); 989#endif 990} 991 992static void 993obj_elf_subsection (ignore) 994 int ignore ATTRIBUTE_UNUSED; 995{ 996 register int temp; 997 998#ifdef md_flush_pending_output 999 md_flush_pending_output (); 1000#endif 1001 1002 previous_section = now_seg; 1003 previous_subsection = now_subseg; 1004 1005 temp = get_absolute_expression (); 1006 subseg_set (now_seg, (subsegT) temp); 1007 demand_empty_rest_of_line (); 1008 1009#ifdef md_elf_section_change_hook 1010 md_elf_section_change_hook (); 1011#endif 1012} 1013 1014/* This can be called from the processor backends if they change 1015 sections. */ 1016 1017void 1018obj_elf_section_change_hook () 1019{ 1020 previous_section = now_seg; 1021 previous_subsection = now_subseg; 1022} 1023 1024void 1025obj_elf_previous (ignore) 1026 int ignore ATTRIBUTE_UNUSED; 1027{ 1028 segT new_section; 1029 int new_subsection; 1030 1031 if (previous_section == 0) 1032 { 1033 as_bad (_(".previous without corresponding .section; ignored")); 1034 return; 1035 } 1036 1037#ifdef md_flush_pending_output 1038 md_flush_pending_output (); 1039#endif 1040 1041 new_section = previous_section; 1042 new_subsection = previous_subsection; 1043 previous_section = now_seg; 1044 previous_subsection = now_subseg; 1045 subseg_set (new_section, new_subsection); 1046 1047#ifdef md_elf_section_change_hook 1048 md_elf_section_change_hook (); 1049#endif 1050} 1051 1052static void 1053obj_elf_popsection (xxx) 1054 int xxx ATTRIBUTE_UNUSED; 1055{ 1056 struct section_stack *top = section_stack; 1057 1058 if (top == NULL) 1059 { 1060 as_bad (_(".popsection without corresponding .pushsection; ignored")); 1061 return; 1062 } 1063 1064#ifdef md_flush_pending_output 1065 md_flush_pending_output (); 1066#endif 1067 1068 section_stack = top->next; 1069 previous_section = top->prev_seg; 1070 previous_subsection = top->prev_subseg; 1071 subseg_set (top->seg, top->subseg); 1072 free (top); 1073 1074#ifdef md_elf_section_change_hook 1075 md_elf_section_change_hook (); 1076#endif 1077} 1078 1079static void 1080obj_elf_line (ignore) 1081 int ignore ATTRIBUTE_UNUSED; 1082{ 1083 /* Assume delimiter is part of expression. BSD4.2 as fails with 1084 delightful bug, so we are not being incompatible here. */ 1085 new_logical_line ((char *) NULL, (int) (get_absolute_expression ())); 1086 demand_empty_rest_of_line (); 1087} 1088 1089/* This handles the .symver pseudo-op, which is used to specify a 1090 symbol version. The syntax is ``.symver NAME,SYMVERNAME''. 1091 SYMVERNAME may contain ELF_VER_CHR ('@') characters. This 1092 pseudo-op causes the assembler to emit a symbol named SYMVERNAME 1093 with the same value as the symbol NAME. */ 1094 1095static void 1096obj_elf_symver (ignore) 1097 int ignore ATTRIBUTE_UNUSED; 1098{ 1099 char *name; 1100 char c; 1101 symbolS *sym; 1102 1103 name = input_line_pointer; 1104 c = get_symbol_end (); 1105 1106 sym = symbol_find_or_make (name); 1107 1108 *input_line_pointer = c; 1109 1110 SKIP_WHITESPACE (); 1111 if (*input_line_pointer != ',') 1112 { 1113 as_bad (_("expected comma after name in .symver")); 1114 ignore_rest_of_line (); 1115 return; 1116 } 1117 1118 ++input_line_pointer; 1119 name = input_line_pointer; 1120 while (1) 1121 { 1122 c = get_symbol_end (); 1123 if (c != ELF_VER_CHR) 1124 break; 1125 *input_line_pointer++ = c; 1126 } 1127 1128 if (symbol_get_obj (sym)->versioned_name == NULL) 1129 { 1130 symbol_get_obj (sym)->versioned_name = xstrdup (name); 1131 1132 *input_line_pointer = c; 1133 1134 if (strchr (symbol_get_obj (sym)->versioned_name, 1135 ELF_VER_CHR) == NULL) 1136 { 1137 as_bad (_("missing version name in `%s' for symbol `%s'"), 1138 symbol_get_obj (sym)->versioned_name, 1139 S_GET_NAME (sym)); 1140 ignore_rest_of_line (); 1141 return; 1142 } 1143 } 1144 else 1145 { 1146 if (strcmp (symbol_get_obj (sym)->versioned_name, name)) 1147 { 1148 as_bad (_("multiple versions [`%s'|`%s'] for symbol `%s'"), 1149 name, symbol_get_obj (sym)->versioned_name, 1150 S_GET_NAME (sym)); 1151 ignore_rest_of_line (); 1152 return; 1153 } 1154 1155 *input_line_pointer = c; 1156 } 1157 1158 demand_empty_rest_of_line (); 1159} 1160 1161/* This handles the .vtable_inherit pseudo-op, which is used to indicate 1162 to the linker the hierarchy in which a particular table resides. The 1163 syntax is ".vtable_inherit CHILDNAME, PARENTNAME". */ 1164 1165struct fix * 1166obj_elf_vtable_inherit (ignore) 1167 int ignore ATTRIBUTE_UNUSED; 1168{ 1169 char *cname, *pname; 1170 symbolS *csym, *psym; 1171 char c, bad = 0; 1172 1173 if (*input_line_pointer == '#') 1174 ++input_line_pointer; 1175 1176 cname = input_line_pointer; 1177 c = get_symbol_end (); 1178 csym = symbol_find (cname); 1179 1180 /* GCFIXME: should check that we don't have two .vtable_inherits for 1181 the same child symbol. Also, we can currently only do this if the 1182 child symbol is already exists and is placed in a fragment. */ 1183 1184 if (csym == NULL || symbol_get_frag (csym) == NULL) 1185 { 1186 as_bad ("expected `%s' to have already been set for .vtable_inherit", 1187 cname); 1188 bad = 1; 1189 } 1190 1191 *input_line_pointer = c; 1192 1193 SKIP_WHITESPACE (); 1194 if (*input_line_pointer != ',') 1195 { 1196 as_bad ("expected comma after name in .vtable_inherit"); 1197 ignore_rest_of_line (); 1198 return NULL; 1199 } 1200 1201 ++input_line_pointer; 1202 SKIP_WHITESPACE (); 1203 1204 if (*input_line_pointer == '#') 1205 ++input_line_pointer; 1206 1207 if (input_line_pointer[0] == '0' 1208 && (input_line_pointer[1] == '\0' 1209 || isspace ((unsigned char) input_line_pointer[1]))) 1210 { 1211 psym = section_symbol (absolute_section); 1212 ++input_line_pointer; 1213 } 1214 else 1215 { 1216 pname = input_line_pointer; 1217 c = get_symbol_end (); 1218 psym = symbol_find_or_make (pname); 1219 *input_line_pointer = c; 1220 } 1221 1222 demand_empty_rest_of_line (); 1223 1224 if (bad) 1225 return NULL; 1226 1227 assert (symbol_get_value_expression (csym)->X_op == O_constant); 1228 return fix_new (symbol_get_frag (csym), 1229 symbol_get_value_expression (csym)->X_add_number, 1230 0, psym, 0, 0, BFD_RELOC_VTABLE_INHERIT); 1231} 1232 1233/* This handles the .vtable_entry pseudo-op, which is used to indicate 1234 to the linker that a vtable slot was used. The syntax is 1235 ".vtable_entry tablename, offset". */ 1236 1237struct fix * 1238obj_elf_vtable_entry (ignore) 1239 int ignore ATTRIBUTE_UNUSED; 1240{ 1241 char *name; 1242 symbolS *sym; 1243 offsetT offset; 1244 char c; 1245 1246 if (*input_line_pointer == '#') 1247 ++input_line_pointer; 1248 1249 name = input_line_pointer; 1250 c = get_symbol_end (); 1251 sym = symbol_find_or_make (name); 1252 *input_line_pointer = c; 1253 1254 SKIP_WHITESPACE (); 1255 if (*input_line_pointer != ',') 1256 { 1257 as_bad ("expected comma after name in .vtable_entry"); 1258 ignore_rest_of_line (); 1259 return NULL; 1260 } 1261 1262 ++input_line_pointer; 1263 if (*input_line_pointer == '#') 1264 ++input_line_pointer; 1265 1266 offset = get_absolute_expression (); 1267 1268 demand_empty_rest_of_line (); 1269 1270 return fix_new (frag_now, frag_now_fix (), 0, sym, offset, 0, 1271 BFD_RELOC_VTABLE_ENTRY); 1272} 1273 1274void 1275elf_obj_read_begin_hook () 1276{ 1277#ifdef NEED_ECOFF_DEBUG 1278 if (ECOFF_DEBUGGING) 1279 ecoff_read_begin_hook (); 1280#endif 1281} 1282 1283void 1284elf_obj_symbol_new_hook (symbolP) 1285 symbolS *symbolP; 1286{ 1287 struct elf_obj_sy *sy_obj; 1288 1289 sy_obj = symbol_get_obj (symbolP); 1290 sy_obj->size = NULL; 1291 sy_obj->versioned_name = NULL; 1292 1293#ifdef NEED_ECOFF_DEBUG 1294 if (ECOFF_DEBUGGING) 1295 ecoff_symbol_new_hook (symbolP); 1296#endif 1297} 1298 1299void 1300obj_elf_version (ignore) 1301 int ignore ATTRIBUTE_UNUSED; 1302{ 1303 char *name; 1304 unsigned int c; 1305 char ch; 1306 char *p; 1307 asection *seg = now_seg; 1308 subsegT subseg = now_subseg; 1309 Elf_Internal_Note i_note; 1310 Elf_External_Note e_note; 1311 asection *note_secp = (asection *) NULL; 1312 int i, len; 1313 1314 SKIP_WHITESPACE (); 1315 if (*input_line_pointer == '\"') 1316 { 1317 ++input_line_pointer; /* -> 1st char of string. */ 1318 name = input_line_pointer; 1319 1320 while (is_a_char (c = next_char_of_string ())) 1321 ; 1322 c = *input_line_pointer; 1323 *input_line_pointer = '\0'; 1324 *(input_line_pointer - 1) = '\0'; 1325 *input_line_pointer = c; 1326 1327 /* create the .note section */ 1328 1329 note_secp = subseg_new (".note", 0); 1330 bfd_set_section_flags (stdoutput, 1331 note_secp, 1332 SEC_HAS_CONTENTS | SEC_READONLY); 1333 1334 /* process the version string */ 1335 1336 len = strlen (name); 1337 1338 i_note.namesz = ((len + 1) + 3) & ~3; /* round this to word boundary */ 1339 i_note.descsz = 0; /* no description */ 1340 i_note.type = NT_VERSION; 1341 p = frag_more (sizeof (e_note.namesz)); 1342 md_number_to_chars (p, (valueT) i_note.namesz, 4); 1343 p = frag_more (sizeof (e_note.descsz)); 1344 md_number_to_chars (p, (valueT) i_note.descsz, 4); 1345 p = frag_more (sizeof (e_note.type)); 1346 md_number_to_chars (p, (valueT) i_note.type, 4); 1347 1348 for (i = 0; i < len; i++) 1349 { 1350 ch = *(name + i); 1351 { 1352 FRAG_APPEND_1_CHAR (ch); 1353 } 1354 } 1355 frag_align (2, 0, 0); 1356 1357 subseg_set (seg, subseg); 1358 } 1359 else 1360 { 1361 as_bad (_("Expected quoted string")); 1362 } 1363 demand_empty_rest_of_line (); 1364} 1365 1366static void 1367obj_elf_size (ignore) 1368 int ignore ATTRIBUTE_UNUSED; 1369{ 1370 char *name = input_line_pointer; 1371 char c = get_symbol_end (); 1372 char *p; 1373 expressionS exp; 1374 symbolS *sym; 1375 1376 p = input_line_pointer; 1377 *p = c; 1378 SKIP_WHITESPACE (); 1379 if (*input_line_pointer != ',') 1380 { 1381 *p = 0; 1382 as_bad (_("expected comma after name `%s' in .size directive"), name); 1383 *p = c; 1384 ignore_rest_of_line (); 1385 return; 1386 } 1387 input_line_pointer++; 1388 expression (&exp); 1389 if (exp.X_op == O_absent) 1390 { 1391 as_bad (_("missing expression in .size directive")); 1392 exp.X_op = O_constant; 1393 exp.X_add_number = 0; 1394 } 1395 *p = 0; 1396 sym = symbol_find_or_make (name); 1397 *p = c; 1398 if (exp.X_op == O_constant) 1399 S_SET_SIZE (sym, exp.X_add_number); 1400 else 1401 { 1402 symbol_get_obj (sym)->size = 1403 (expressionS *) xmalloc (sizeof (expressionS)); 1404 *symbol_get_obj (sym)->size = exp; 1405 } 1406 demand_empty_rest_of_line (); 1407} 1408 1409/* Handle the ELF .type pseudo-op. This sets the type of a symbol. 1410 There are five syntaxes: 1411 1412 The first (used on Solaris) is 1413 .type SYM,#function 1414 The second (used on UnixWare) is 1415 .type SYM,@function 1416 The third (reportedly to be used on Irix 6.0) is 1417 .type SYM STT_FUNC 1418 The fourth (used on NetBSD/Arm and Linux/ARM) is 1419 .type SYM,%function 1420 The fifth (used on SVR4/860) is 1421 .type SYM,"function" 1422 */ 1423 1424static void 1425obj_elf_type (ignore) 1426 int ignore ATTRIBUTE_UNUSED; 1427{ 1428 char *name; 1429 char c; 1430 int type; 1431 const char *typename; 1432 symbolS *sym; 1433 elf_symbol_type *elfsym; 1434 1435 name = input_line_pointer; 1436 c = get_symbol_end (); 1437 sym = symbol_find_or_make (name); 1438 elfsym = (elf_symbol_type *) symbol_get_bfdsym (sym); 1439 *input_line_pointer = c; 1440 1441 SKIP_WHITESPACE (); 1442 if (*input_line_pointer == ',') 1443 ++input_line_pointer; 1444 1445 SKIP_WHITESPACE (); 1446 if ( *input_line_pointer == '#' 1447 || *input_line_pointer == '@' 1448 || *input_line_pointer == '"' 1449 || *input_line_pointer == '%') 1450 ++input_line_pointer; 1451 1452 typename = input_line_pointer; 1453 c = get_symbol_end (); 1454 1455 type = 0; 1456 if (strcmp (typename, "function") == 0 1457 || strcmp (typename, "STT_FUNC") == 0) 1458 type = BSF_FUNCTION; 1459 else if (strcmp (typename, "object") == 0 1460 || strcmp (typename, "STT_OBJECT") == 0) 1461 type = BSF_OBJECT; 1462#ifdef md_elf_symbol_type 1463 else if ((type = md_elf_symbol_type (typename, sym, elfsym)) != -1) 1464 ; 1465#endif 1466 else 1467 as_bad (_("ignoring unrecognized symbol type \"%s\""), typename); 1468 1469 *input_line_pointer = c; 1470 1471 if (*input_line_pointer == '"') 1472 ++input_line_pointer; 1473 1474 elfsym->symbol.flags |= type; 1475 1476 demand_empty_rest_of_line (); 1477} 1478 1479static void 1480obj_elf_ident (ignore) 1481 int ignore ATTRIBUTE_UNUSED; 1482{ 1483 static segT comment_section; 1484 segT old_section = now_seg; 1485 int old_subsection = now_subseg; 1486 1487#ifdef md_flush_pending_output 1488 md_flush_pending_output (); 1489#endif 1490 1491 if (!comment_section) 1492 { 1493 char *p; 1494 comment_section = subseg_new (".comment", 0); 1495 bfd_set_section_flags (stdoutput, comment_section, 1496 SEC_READONLY | SEC_HAS_CONTENTS); 1497 p = frag_more (1); 1498 *p = 0; 1499 } 1500 else 1501 subseg_set (comment_section, 0); 1502 stringer (1); 1503 subseg_set (old_section, old_subsection); 1504} 1505 1506#ifdef INIT_STAB_SECTION 1507 1508/* The first entry in a .stabs section is special. */ 1509 1510void 1511obj_elf_init_stab_section (seg) 1512 segT seg; 1513{ 1514 char *file; 1515 char *p; 1516 char *stabstr_name; 1517 unsigned int stroff; 1518 1519 /* Force the section to align to a longword boundary. Without this, 1520 UnixWare ar crashes. */ 1521 bfd_set_section_alignment (stdoutput, seg, 2); 1522 1523 /* Make space for this first symbol. */ 1524 p = frag_more (12); 1525 /* Zero it out. */ 1526 memset (p, 0, 12); 1527 as_where (&file, (unsigned int *) NULL); 1528 stabstr_name = (char *) alloca (strlen (segment_name (seg)) + 4); 1529 strcpy (stabstr_name, segment_name (seg)); 1530 strcat (stabstr_name, "str"); 1531 stroff = get_stab_string_offset (file, stabstr_name); 1532 know (stroff == 1); 1533 md_number_to_chars (p, stroff, 4); 1534 seg_info (seg)->stabu.p = p; 1535} 1536 1537#endif 1538 1539/* Fill in the counts in the first entry in a .stabs section. */ 1540 1541static void 1542adjust_stab_sections (abfd, sec, xxx) 1543 bfd *abfd; 1544 asection *sec; 1545 PTR xxx ATTRIBUTE_UNUSED; 1546{ 1547 char *name; 1548 asection *strsec; 1549 char *p; 1550 int strsz, nsyms; 1551 1552 if (strncmp (".stab", sec->name, 5)) 1553 return; 1554 if (!strcmp ("str", sec->name + strlen (sec->name) - 3)) 1555 return; 1556 1557 name = (char *) alloca (strlen (sec->name) + 4); 1558 strcpy (name, sec->name); 1559 strcat (name, "str"); 1560 strsec = bfd_get_section_by_name (abfd, name); 1561 if (strsec) 1562 strsz = bfd_section_size (abfd, strsec); 1563 else 1564 strsz = 0; 1565 nsyms = bfd_section_size (abfd, sec) / 12 - 1; 1566 1567 p = seg_info (sec)->stabu.p; 1568 assert (p != 0); 1569 1570 bfd_h_put_16 (abfd, (bfd_vma) nsyms, (bfd_byte *) p + 6); 1571 bfd_h_put_32 (abfd, (bfd_vma) strsz, (bfd_byte *) p + 8); 1572} 1573 1574#ifdef NEED_ECOFF_DEBUG 1575 1576/* This function is called by the ECOFF code. It is supposed to 1577 record the external symbol information so that the backend can 1578 write it out correctly. The ELF backend doesn't actually handle 1579 this at the moment, so we do it ourselves. We save the information 1580 in the symbol. */ 1581 1582void 1583elf_ecoff_set_ext (sym, ext) 1584 symbolS *sym; 1585 struct ecoff_extr *ext; 1586{ 1587 symbol_get_bfdsym (sym)->udata.p = (PTR) ext; 1588} 1589 1590/* This function is called by bfd_ecoff_debug_externals. It is 1591 supposed to *EXT to the external symbol information, and return 1592 whether the symbol should be used at all. */ 1593 1594static boolean 1595elf_get_extr (sym, ext) 1596 asymbol *sym; 1597 EXTR *ext; 1598{ 1599 if (sym->udata.p == NULL) 1600 return false; 1601 *ext = *(EXTR *) sym->udata.p; 1602 return true; 1603} 1604 1605/* This function is called by bfd_ecoff_debug_externals. It has 1606 nothing to do for ELF. */ 1607 1608/*ARGSUSED*/ 1609static void 1610elf_set_index (sym, indx) 1611 asymbol *sym ATTRIBUTE_UNUSED; 1612 bfd_size_type indx ATTRIBUTE_UNUSED; 1613{ 1614} 1615 1616#endif /* NEED_ECOFF_DEBUG */ 1617 1618void 1619elf_frob_symbol (symp, puntp) 1620 symbolS *symp; 1621 int *puntp; 1622{ 1623 struct elf_obj_sy *sy_obj; 1624 1625#ifdef NEED_ECOFF_DEBUG 1626 if (ECOFF_DEBUGGING) 1627 ecoff_frob_symbol (symp); 1628#endif 1629 1630 sy_obj = symbol_get_obj (symp); 1631 1632 if (sy_obj->size != NULL) 1633 { 1634 switch (sy_obj->size->X_op) 1635 { 1636 case O_subtract: 1637 S_SET_SIZE (symp, 1638 (S_GET_VALUE (sy_obj->size->X_add_symbol) 1639 + sy_obj->size->X_add_number 1640 - S_GET_VALUE (sy_obj->size->X_op_symbol))); 1641 break; 1642 case O_constant: 1643 S_SET_SIZE (symp, 1644 (S_GET_VALUE (sy_obj->size->X_add_symbol) 1645 + sy_obj->size->X_add_number)); 1646 break; 1647 default: 1648 as_bad (_(".size expression too complicated to fix up")); 1649 break; 1650 } 1651 free (sy_obj->size); 1652 sy_obj->size = NULL; 1653 } 1654 1655 if (sy_obj->versioned_name != NULL) 1656 { 1657 char *p; 1658 1659 p = strchr (sy_obj->versioned_name, ELF_VER_CHR); 1660 know (p != NULL); 1661 1662 /* This symbol was given a new name with the .symver directive. 1663 1664 If this is an external reference, just rename the symbol to 1665 include the version string. This will make the relocs be 1666 against the correct versioned symbol. 1667 1668 If this is a definition, add an alias. FIXME: Using an alias 1669 will permit the debugging information to refer to the right 1670 symbol. However, it's not clear whether it is the best 1671 approach. */ 1672 1673 if (! S_IS_DEFINED (symp)) 1674 { 1675 /* Verify that the name isn't using the @@ syntax--this is 1676 reserved for definitions of the default version to link 1677 against. */ 1678 if (p[1] == ELF_VER_CHR) 1679 { 1680 as_bad (_("invalid attempt to declare external version name as default in symbol `%s'"), 1681 sy_obj->versioned_name); 1682 *puntp = true; 1683 } 1684 S_SET_NAME (symp, sy_obj->versioned_name); 1685 } 1686 else 1687 { 1688 if (p [1] == ELF_VER_CHR && p [2] == ELF_VER_CHR) 1689 { 1690 size_t l; 1691 1692 /* The @@@ syntax is a special case. It renames the 1693 symbol name to versioned_name with one `@' removed. */ 1694 l = strlen (&p[3]) + 1; 1695 memmove (&p [2], &p[3], l); 1696 S_SET_NAME (symp, sy_obj->versioned_name); 1697 } 1698 else 1699 { 1700 symbolS *symp2; 1701 1702 /* FIXME: Creating a new symbol here is risky. We're 1703 in the final loop over the symbol table. We can 1704 get away with it only because the symbol goes to 1705 the end of the list, where the loop will still see 1706 it. It would probably be better to do this in 1707 obj_frob_file_before_adjust. */ 1708 1709 symp2 = symbol_find_or_make (sy_obj->versioned_name); 1710 1711 /* Now we act as though we saw symp2 = sym. */ 1712 1713 S_SET_SEGMENT (symp2, S_GET_SEGMENT (symp)); 1714 1715 /* Subtracting out the frag address here is a hack 1716 because we are in the middle of the final loop. */ 1717 S_SET_VALUE (symp2, 1718 (S_GET_VALUE (symp) 1719 - symbol_get_frag (symp)->fr_address)); 1720 1721 symbol_set_frag (symp2, symbol_get_frag (symp)); 1722 1723 /* This will copy over the size information. */ 1724 copy_symbol_attributes (symp2, symp); 1725 1726 if (S_IS_WEAK (symp)) 1727 S_SET_WEAK (symp2); 1728 1729 if (S_IS_EXTERNAL (symp)) 1730 S_SET_EXTERNAL (symp2); 1731 } 1732 } 1733 } 1734 1735 /* Double check weak symbols. */ 1736 if (S_IS_WEAK (symp)) 1737 { 1738 if (S_IS_COMMON (symp)) 1739 as_bad (_("Symbol `%s' can not be both weak and common"), 1740 S_GET_NAME (symp)); 1741 } 1742 1743#ifdef TC_MIPS 1744 /* The Irix 5 and 6 assemblers set the type of any common symbol and 1745 any undefined non-function symbol to STT_OBJECT. We try to be 1746 compatible, since newer Irix 5 and 6 linkers care. However, we 1747 only set undefined symbols to be STT_OBJECT if we are on Irix, 1748 because that is the only time gcc will generate the necessary 1749 .global directives to mark functions. */ 1750 1751 if (S_IS_COMMON (symp)) 1752 symbol_get_bfdsym (symp)->flags |= BSF_OBJECT; 1753 1754 if (strstr (TARGET_OS, "irix") != NULL 1755 && ! S_IS_DEFINED (symp) 1756 && (symbol_get_bfdsym (symp)->flags & BSF_FUNCTION) == 0) 1757 symbol_get_bfdsym (symp)->flags |= BSF_OBJECT; 1758#endif 1759 1760#if 0 /* TC_PPC */ 1761 /* If TC_PPC is defined, we used to force the type of a symbol to be 1762 BSF_OBJECT if it was otherwise unset. This was required by some 1763 version of VxWorks. Thomas de Lellis <tdel@windriver.com> says 1764 that this is no longer needed, so it is now commented out. */ 1765 if ((symbol_get_bfdsym (symp)->flags 1766 & (BSF_FUNCTION | BSF_FILE | BSF_SECTION_SYM)) == 0 1767 && S_IS_DEFINED (symp)) 1768 symbol_get_bfdsym (symp)->flags |= BSF_OBJECT; 1769#endif 1770} 1771 1772void 1773elf_frob_file () 1774{ 1775 bfd_map_over_sections (stdoutput, adjust_stab_sections, (PTR) 0); 1776 1777#ifdef elf_tc_final_processing 1778 elf_tc_final_processing (); 1779#endif 1780} 1781 1782/* It removes any unneeded versioned symbols from the symbol table. */ 1783 1784void 1785elf_frob_file_before_adjust () 1786{ 1787 if (symbol_rootP) 1788 { 1789 symbolS *symp; 1790 1791 for (symp = symbol_rootP; symp; symp = symbol_next (symp)) 1792 if (symbol_get_obj (symp)->versioned_name) 1793 { 1794 if (!S_IS_DEFINED (symp)) 1795 { 1796 char *p; 1797 1798 /* The @@@ syntax is a special case. If the symbol is 1799 not defined, 2 `@'s will be removed from the 1800 versioned_name. */ 1801 1802 p = strchr (symbol_get_obj (symp)->versioned_name, 1803 ELF_VER_CHR); 1804 know (p != NULL); 1805 if (p [1] == ELF_VER_CHR && p [2] == ELF_VER_CHR) 1806 { 1807 size_t l = strlen (&p[3]) + 1; 1808 memmove (&p [1], &p[3], l); 1809 } 1810 if (symbol_used_p (symp) == 0 1811 && symbol_used_in_reloc_p (symp) == 0) 1812 symbol_remove (symp, &symbol_rootP, &symbol_lastP); 1813 } 1814 } 1815 } 1816} 1817 1818/* It is required that we let write_relocs have the opportunity to 1819 optimize away fixups before output has begun, since it is possible 1820 to eliminate all fixups for a section and thus we never should 1821 have generated the relocation section. */ 1822 1823void 1824elf_frob_file_after_relocs () 1825{ 1826#ifdef NEED_ECOFF_DEBUG 1827 if (ECOFF_DEBUGGING) 1828 /* Generate the ECOFF debugging information. */ 1829 { 1830 const struct ecoff_debug_swap *debug_swap; 1831 struct ecoff_debug_info debug; 1832 char *buf; 1833 asection *sec; 1834 1835 debug_swap 1836 = get_elf_backend_data (stdoutput)->elf_backend_ecoff_debug_swap; 1837 know (debug_swap != (const struct ecoff_debug_swap *) NULL); 1838 ecoff_build_debug (&debug.symbolic_header, &buf, debug_swap); 1839 1840 /* Set up the pointers in debug. */ 1841#define SET(ptr, offset, type) \ 1842 debug.ptr = (type) (buf + debug.symbolic_header.offset) 1843 1844 SET (line, cbLineOffset, unsigned char *); 1845 SET (external_dnr, cbDnOffset, PTR); 1846 SET (external_pdr, cbPdOffset, PTR); 1847 SET (external_sym, cbSymOffset, PTR); 1848 SET (external_opt, cbOptOffset, PTR); 1849 SET (external_aux, cbAuxOffset, union aux_ext *); 1850 SET (ss, cbSsOffset, char *); 1851 SET (external_fdr, cbFdOffset, PTR); 1852 SET (external_rfd, cbRfdOffset, PTR); 1853 /* ssext and external_ext are set up just below. */ 1854 1855#undef SET 1856 1857 /* Set up the external symbols. */ 1858 debug.ssext = debug.ssext_end = NULL; 1859 debug.external_ext = debug.external_ext_end = NULL; 1860 if (! bfd_ecoff_debug_externals (stdoutput, &debug, debug_swap, true, 1861 elf_get_extr, elf_set_index)) 1862 as_fatal (_("Failed to set up debugging information: %s"), 1863 bfd_errmsg (bfd_get_error ())); 1864 1865 sec = bfd_get_section_by_name (stdoutput, ".mdebug"); 1866 assert (sec != NULL); 1867 1868 know (stdoutput->output_has_begun == false); 1869 1870 /* We set the size of the section, call bfd_set_section_contents 1871 to force the ELF backend to allocate a file position, and then 1872 write out the data. FIXME: Is this really the best way to do 1873 this? */ 1874 sec->_raw_size = bfd_ecoff_debug_size (stdoutput, &debug, debug_swap); 1875 1876 /* Pass BUF to bfd_set_section_contents because this will 1877 eventually become a call to fwrite, and ISO C prohibits 1878 passing a NULL pointer to a stdio function even if the 1879 pointer will not be used. */ 1880 if (! bfd_set_section_contents (stdoutput, sec, (PTR) buf, 1881 (file_ptr) 0, (bfd_size_type) 0)) 1882 as_fatal (_("Can't start writing .mdebug section: %s"), 1883 bfd_errmsg (bfd_get_error ())); 1884 1885 know (stdoutput->output_has_begun == true); 1886 know (sec->filepos != 0); 1887 1888 if (! bfd_ecoff_write_debug (stdoutput, &debug, debug_swap, 1889 sec->filepos)) 1890 as_fatal (_("Could not write .mdebug section: %s"), 1891 bfd_errmsg (bfd_get_error ())); 1892 } 1893#endif /* NEED_ECOFF_DEBUG */ 1894} 1895 1896#ifdef SCO_ELF 1897 1898/* Heavily plagarized from obj_elf_version. The idea is to emit the 1899 SCO specific identifier in the .notes section to satisfy the SCO 1900 linker. 1901 1902 This looks more complicated than it really is. As opposed to the 1903 "obvious" solution, this should handle the cross dev cases 1904 correctly. (i.e, hosting on a 64 bit big endian processor, but 1905 generating SCO Elf code) Efficiency isn't a concern, as there 1906 should be exactly one of these sections per object module. 1907 1908 SCO OpenServer 5 identifies it's ELF modules with a standard ELF 1909 .note section. 1910 1911 int_32 namesz = 4 ; Name size 1912 int_32 descsz = 12 ; Descriptive information 1913 int_32 type = 1 ; 1914 char name[4] = "SCO" ; Originator name ALWAYS SCO + NULL 1915 int_32 version = (major ver # << 16) | version of tools ; 1916 int_32 source = (tool_id << 16 ) | 1 ; 1917 int_32 info = 0 ; These are set by the SCO tools, but we 1918 don't know enough about the source 1919 environment to set them. SCO ld currently 1920 ignores them, and recommends we set them 1921 to zero. */ 1922 1923#define SCO_MAJOR_VERSION 0x1 1924#define SCO_MINOR_VERSION 0x1 1925 1926void 1927sco_id () 1928{ 1929 1930 char *name; 1931 unsigned int c; 1932 char ch; 1933 char *p; 1934 asection *seg = now_seg; 1935 subsegT subseg = now_subseg; 1936 Elf_Internal_Note i_note; 1937 Elf_External_Note e_note; 1938 asection *note_secp = (asection *) NULL; 1939 int i, len; 1940 1941 /* create the .note section */ 1942 1943 note_secp = subseg_new (".note", 0); 1944 bfd_set_section_flags (stdoutput, 1945 note_secp, 1946 SEC_HAS_CONTENTS | SEC_READONLY); 1947 1948 /* process the version string */ 1949 1950 i_note.namesz = 4; 1951 i_note.descsz = 12; /* 12 descriptive bytes */ 1952 i_note.type = NT_VERSION; /* Contains a version string */ 1953 1954 p = frag_more (sizeof (i_note.namesz)); 1955 md_number_to_chars (p, (valueT) i_note.namesz, 4); 1956 1957 p = frag_more (sizeof (i_note.descsz)); 1958 md_number_to_chars (p, (valueT) i_note.descsz, 4); 1959 1960 p = frag_more (sizeof (i_note.type)); 1961 md_number_to_chars (p, (valueT) i_note.type, 4); 1962 1963 p = frag_more (4); 1964 strcpy (p, "SCO"); 1965 1966 /* Note: this is the version number of the ELF we're representing */ 1967 p = frag_more (4); 1968 md_number_to_chars (p, (SCO_MAJOR_VERSION << 16) | (SCO_MINOR_VERSION), 4); 1969 1970 /* Here, we pick a magic number for ourselves (yes, I "registered" 1971 it with SCO. The bottom bit shows that we are compat with the 1972 SCO ABI. */ 1973 p = frag_more (4); 1974 md_number_to_chars (p, 0x4c520000 | 0x0001, 4); 1975 1976 /* If we knew (or cared) what the source language options were, we'd 1977 fill them in here. SCO has given us permission to ignore these 1978 and just set them to zero. */ 1979 p = frag_more (4); 1980 md_number_to_chars (p, 0x0000, 4); 1981 1982 frag_align (2, 0, 0); 1983 1984 /* We probably can't restore the current segment, for there likely 1985 isn't one yet... */ 1986 if (seg && subseg) 1987 subseg_set (seg, subseg); 1988 1989} 1990 1991#endif /* SCO_ELF */ 1992 1993static int 1994elf_separate_stab_sections () 1995{ 1996#ifdef NEED_ECOFF_DEBUG 1997 return (!ECOFF_DEBUGGING); 1998#else 1999 return 1; 2000#endif 2001} 2002 2003static void 2004elf_init_stab_section (seg) 2005 segT seg; 2006{ 2007#ifdef NEED_ECOFF_DEBUG 2008 if (!ECOFF_DEBUGGING) 2009#endif 2010 obj_elf_init_stab_section (seg); 2011} 2012 2013const struct format_ops elf_format_ops = 2014{ 2015 bfd_target_elf_flavour, 2016 0, /* dfl_leading_underscore */ 2017 1, /* emit_section_symbols */ 2018 elf_begin, 2019 elf_file_symbol, 2020 elf_frob_symbol, 2021 elf_frob_file, 2022 elf_frob_file_before_adjust, 2023 elf_frob_file_after_relocs, 2024 elf_s_get_size, elf_s_set_size, 2025 elf_s_get_align, elf_s_set_align, 2026 elf_s_get_other, 2027 elf_s_set_other, 2028 0, /* s_get_desc */ 2029 0, /* s_set_desc */ 2030 0, /* s_get_type */ 2031 0, /* s_set_type */ 2032 elf_copy_symbol_attributes, 2033#ifdef NEED_ECOFF_DEBUG 2034 ecoff_generate_asm_lineno, 2035 ecoff_stab, 2036#else 2037 0, /* generate_asm_lineno */ 2038 0, /* process_stab */ 2039#endif 2040 elf_separate_stab_sections, 2041 elf_init_stab_section, 2042 elf_sec_sym_ok_for_reloc, 2043 elf_pop_insert, 2044#ifdef NEED_ECOFF_DEBUG 2045 elf_ecoff_set_ext, 2046#else 2047 0, /* ecoff_set_ext */ 2048#endif 2049 elf_obj_read_begin_hook, 2050 elf_obj_symbol_new_hook 2051}; 2052