1 /* ELF object file format 2 Copyright (C) 1992-2014 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 8 published by the Free Software Foundation; either version 3, 9 or (at your option) any later version. 10 11 GAS is distributed in the hope that it will be useful, but 12 WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See 14 the 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 OBJ_HEADER "obj-elf.h" 22 #include "as.h" 23 #include "safe-ctype.h" 24 #include "subsegs.h" 25 #include "obstack.h" 26 #include "struc-symbol.h" 27 #include "dwarf2dbg.h" 28 29 #ifndef ECOFF_DEBUGGING 30 #define ECOFF_DEBUGGING 0 31 #else 32 #define NEED_ECOFF_DEBUG 33 #endif 34 35 #ifdef NEED_ECOFF_DEBUG 36 #include "ecoff.h" 37 #endif 38 39 #ifdef TC_ALPHA 40 #include "elf/alpha.h" 41 #endif 42 43 #ifdef TC_MIPS 44 #include "elf/mips.h" 45 #endif 46 47 #ifdef TC_PPC 48 #include "elf/ppc.h" 49 #endif 50 51 #ifdef TC_I370 52 #include "elf/i370.h" 53 #endif 54 55 #ifdef TC_I386 56 #include "elf/x86-64.h" 57 #endif 58 59 #ifdef TC_MEP 60 #include "elf/mep.h" 61 #endif 62 63 #ifdef TC_NIOS2 64 #include "elf/nios2.h" 65 #endif 66 67 static void obj_elf_line (int); 68 static void obj_elf_size (int); 69 static void obj_elf_type (int); 70 static void obj_elf_ident (int); 71 static void obj_elf_weak (int); 72 static void obj_elf_local (int); 73 static void obj_elf_visibility (int); 74 static void obj_elf_symver (int); 75 static void obj_elf_subsection (int); 76 static void obj_elf_popsection (int); 77 static void obj_elf_gnu_attribute (int); 78 static void obj_elf_tls_common (int); 79 static void obj_elf_lcomm (int); 80 static void obj_elf_struct (int); 81 82 static const pseudo_typeS elf_pseudo_table[] = 83 { 84 {"comm", obj_elf_common, 0}, 85 {"common", obj_elf_common, 1}, 86 {"ident", obj_elf_ident, 0}, 87 {"lcomm", obj_elf_lcomm, 0}, 88 {"local", obj_elf_local, 0}, 89 {"previous", obj_elf_previous, 0}, 90 {"section", obj_elf_section, 0}, 91 {"section.s", obj_elf_section, 0}, 92 {"sect", obj_elf_section, 0}, 93 {"sect.s", obj_elf_section, 0}, 94 {"pushsection", obj_elf_section, 1}, 95 {"popsection", obj_elf_popsection, 0}, 96 {"size", obj_elf_size, 0}, 97 {"type", obj_elf_type, 0}, 98 {"version", obj_elf_version, 0}, 99 {"weak", obj_elf_weak, 0}, 100 101 /* These define symbol visibility. */ 102 {"internal", obj_elf_visibility, STV_INTERNAL}, 103 {"hidden", obj_elf_visibility, STV_HIDDEN}, 104 {"protected", obj_elf_visibility, STV_PROTECTED}, 105 106 /* These are used for stabs-in-elf configurations. */ 107 {"line", obj_elf_line, 0}, 108 109 /* This is a GNU extension to handle symbol versions. */ 110 {"symver", obj_elf_symver, 0}, 111 112 /* A GNU extension to change subsection only. */ 113 {"subsection", obj_elf_subsection, 0}, 114 115 /* These are GNU extensions to aid in garbage collecting C++ vtables. */ 116 {"vtable_inherit", (void (*) (int)) &obj_elf_vtable_inherit, 0}, 117 {"vtable_entry", (void (*) (int)) &obj_elf_vtable_entry, 0}, 118 119 /* A GNU extension for object attributes. */ 120 {"gnu_attribute", obj_elf_gnu_attribute, 0}, 121 122 /* These are used for dwarf. */ 123 {"2byte", cons, 2}, 124 {"4byte", cons, 4}, 125 {"8byte", cons, 8}, 126 /* These are used for dwarf2. */ 127 { "file", (void (*) (int)) dwarf2_directive_file, 0 }, 128 { "loc", dwarf2_directive_loc, 0 }, 129 { "loc_mark_labels", dwarf2_directive_loc_mark_labels, 0 }, 130 { "lloc", dwarf2_directive_loc, 1 }, 131 { "subprog", dwarf2_directive_subprog, 0 }, 132 133 /* We need to trap the section changing calls to handle .previous. */ 134 {"data", obj_elf_data, 0}, 135 {"offset", obj_elf_struct, 0}, 136 {"struct", obj_elf_struct, 0}, 137 {"text", obj_elf_text, 0}, 138 139 {"tls_common", obj_elf_tls_common, 0}, 140 141 /* End sentinel. */ 142 {NULL, NULL, 0}, 143 }; 144 145 static const pseudo_typeS ecoff_debug_pseudo_table[] = 146 { 147 #ifdef NEED_ECOFF_DEBUG 148 /* COFF style debugging information for ECOFF. .ln is not used; .loc 149 is used instead. */ 150 { "def", ecoff_directive_def, 0 }, 151 { "dim", ecoff_directive_dim, 0 }, 152 { "endef", ecoff_directive_endef, 0 }, 153 { "file", ecoff_directive_file, 0 }, 154 { "scl", ecoff_directive_scl, 0 }, 155 { "tag", ecoff_directive_tag, 0 }, 156 { "val", ecoff_directive_val, 0 }, 157 158 /* COFF debugging requires pseudo-ops .size and .type, but ELF 159 already has meanings for those. We use .esize and .etype 160 instead. These are only generated by gcc anyhow. */ 161 { "esize", ecoff_directive_size, 0 }, 162 { "etype", ecoff_directive_type, 0 }, 163 164 /* ECOFF specific debugging information. */ 165 { "begin", ecoff_directive_begin, 0 }, 166 { "bend", ecoff_directive_bend, 0 }, 167 { "end", ecoff_directive_end, 0 }, 168 { "ent", ecoff_directive_ent, 0 }, 169 { "fmask", ecoff_directive_fmask, 0 }, 170 { "frame", ecoff_directive_frame, 0 }, 171 { "loc", ecoff_directive_loc, 0 }, 172 { "mask", ecoff_directive_mask, 0 }, 173 174 /* Other ECOFF directives. */ 175 { "extern", ecoff_directive_extern, 0 }, 176 177 /* These are used on Irix. I don't know how to implement them. */ 178 { "alias", s_ignore, 0 }, 179 { "bgnb", s_ignore, 0 }, 180 { "endb", s_ignore, 0 }, 181 { "lab", s_ignore, 0 }, 182 { "noalias", s_ignore, 0 }, 183 { "verstamp", s_ignore, 0 }, 184 { "vreg", s_ignore, 0 }, 185 #endif 186 187 {NULL, NULL, 0} /* end sentinel */ 188 }; 189 190 #undef NO_RELOC 191 #include "aout/aout64.h" 192 193 /* This is called when the assembler starts. */ 194 195 asection *elf_com_section_ptr; 196 197 void 198 elf_begin (void) 199 { 200 asection *s; 201 202 /* Add symbols for the known sections to the symbol table. */ 203 s = bfd_get_section_by_name (stdoutput, TEXT_SECTION_NAME); 204 symbol_table_insert (section_symbol (s)); 205 s = bfd_get_section_by_name (stdoutput, DATA_SECTION_NAME); 206 symbol_table_insert (section_symbol (s)); 207 s = bfd_get_section_by_name (stdoutput, BSS_SECTION_NAME); 208 symbol_table_insert (section_symbol (s)); 209 elf_com_section_ptr = bfd_com_section_ptr; 210 } 211 212 void 213 elf_pop_insert (void) 214 { 215 pop_insert (elf_pseudo_table); 216 if (ECOFF_DEBUGGING) 217 pop_insert (ecoff_debug_pseudo_table); 218 } 219 220 static bfd_vma 221 elf_s_get_size (symbolS *sym) 222 { 223 return S_GET_SIZE (sym); 224 } 225 226 static void 227 elf_s_set_size (symbolS *sym, bfd_vma sz) 228 { 229 S_SET_SIZE (sym, sz); 230 } 231 232 static bfd_vma 233 elf_s_get_align (symbolS *sym) 234 { 235 return S_GET_ALIGN (sym); 236 } 237 238 static void 239 elf_s_set_align (symbolS *sym, bfd_vma align) 240 { 241 S_SET_ALIGN (sym, align); 242 } 243 244 int 245 elf_s_get_other (symbolS *sym) 246 { 247 return elf_symbol (symbol_get_bfdsym (sym))->internal_elf_sym.st_other; 248 } 249 250 static void 251 elf_s_set_other (symbolS *sym, int other) 252 { 253 S_SET_OTHER (sym, other); 254 } 255 256 static int 257 elf_sec_sym_ok_for_reloc (asection *sec) 258 { 259 return obj_sec_sym_ok_for_reloc (sec); 260 } 261 262 void 263 elf_file_symbol (const char *s, int appfile) 264 { 265 if (!appfile 266 || symbol_rootP == NULL 267 || symbol_rootP->bsym == NULL 268 || (symbol_rootP->bsym->flags & BSF_FILE) == 0) 269 { 270 symbolS *sym; 271 size_t name_length; 272 273 sym = symbol_new (s, absolute_section, 0, NULL); 274 symbol_set_frag (sym, &zero_address_frag); 275 276 name_length = strlen (s); 277 if (name_length > strlen (S_GET_NAME (sym))) 278 { 279 obstack_grow (¬es, s, name_length + 1); 280 S_SET_NAME (sym, (const char *) obstack_finish (¬es)); 281 } 282 else 283 strcpy ((char *) S_GET_NAME (sym), s); 284 285 symbol_get_bfdsym (sym)->flags |= BSF_FILE; 286 287 if (symbol_rootP != sym) 288 { 289 symbol_remove (sym, &symbol_rootP, &symbol_lastP); 290 symbol_insert (sym, symbol_rootP, &symbol_rootP, &symbol_lastP); 291 #ifdef DEBUG 292 verify_symbol_chain (symbol_rootP, symbol_lastP); 293 #endif 294 } 295 } 296 297 #ifdef NEED_ECOFF_DEBUG 298 ecoff_new_file (s, appfile); 299 #endif 300 } 301 302 /* Called from read.c:s_comm after we've parsed .comm symbol, size. 303 Parse a possible alignment value. */ 304 305 symbolS * 306 elf_common_parse (int ignore ATTRIBUTE_UNUSED, symbolS *symbolP, addressT size) 307 { 308 addressT align = 0; 309 int is_local = symbol_get_obj (symbolP)->local; 310 311 if (*input_line_pointer == ',') 312 { 313 char *save = input_line_pointer; 314 315 input_line_pointer++; 316 SKIP_WHITESPACE (); 317 318 if (*input_line_pointer == '"') 319 { 320 /* For sparc. Accept .common symbol, length, "bss" */ 321 input_line_pointer++; 322 /* Some use the dot, some don't. */ 323 if (*input_line_pointer == '.') 324 input_line_pointer++; 325 /* Some say data, some say bss. */ 326 if (strncmp (input_line_pointer, "bss\"", 4) == 0) 327 input_line_pointer += 4; 328 else if (strncmp (input_line_pointer, "data\"", 5) == 0) 329 input_line_pointer += 5; 330 else 331 { 332 char *p = input_line_pointer; 333 char c; 334 335 while (*--p != '"') 336 ; 337 while (!is_end_of_line[(unsigned char) *input_line_pointer]) 338 if (*input_line_pointer++ == '"') 339 break; 340 c = *input_line_pointer; 341 *input_line_pointer = '\0'; 342 as_bad (_("bad .common segment %s"), p); 343 *input_line_pointer = c; 344 ignore_rest_of_line (); 345 return NULL; 346 } 347 /* ??? Don't ask me why these are always global. */ 348 is_local = 0; 349 } 350 else 351 { 352 input_line_pointer = save; 353 align = parse_align (is_local); 354 if (align == (addressT) -1) 355 return NULL; 356 } 357 } 358 359 if (is_local) 360 { 361 bss_alloc (symbolP, size, align); 362 S_CLEAR_EXTERNAL (symbolP); 363 } 364 else 365 { 366 S_SET_VALUE (symbolP, size); 367 S_SET_ALIGN (symbolP, align); 368 S_SET_EXTERNAL (symbolP); 369 S_SET_SEGMENT (symbolP, elf_com_section_ptr); 370 } 371 372 symbol_get_bfdsym (symbolP)->flags |= BSF_OBJECT; 373 374 return symbolP; 375 } 376 377 void 378 obj_elf_common (int is_common) 379 { 380 if (flag_mri && is_common) 381 s_mri_common (0); 382 else 383 s_comm_internal (0, elf_common_parse); 384 } 385 386 static void 387 obj_elf_tls_common (int ignore ATTRIBUTE_UNUSED) 388 { 389 symbolS *symbolP = s_comm_internal (0, elf_common_parse); 390 391 if (symbolP) 392 symbol_get_bfdsym (symbolP)->flags |= BSF_THREAD_LOCAL; 393 } 394 395 static void 396 obj_elf_lcomm (int ignore ATTRIBUTE_UNUSED) 397 { 398 symbolS *symbolP = s_comm_internal (0, s_lcomm_internal); 399 400 if (symbolP) 401 symbol_get_bfdsym (symbolP)->flags |= BSF_OBJECT; 402 } 403 404 static symbolS * 405 get_sym_from_input_line_and_check (void) 406 { 407 char *name; 408 char c; 409 symbolS *sym; 410 411 name = input_line_pointer; 412 c = get_symbol_end (); 413 sym = symbol_find_or_make (name); 414 *input_line_pointer = c; 415 SKIP_WHITESPACE (); 416 417 /* There is no symbol name if input_line_pointer has not moved. */ 418 if (name == input_line_pointer) 419 as_bad (_("Missing symbol name in directive")); 420 return sym; 421 } 422 423 static void 424 obj_elf_local (int ignore ATTRIBUTE_UNUSED) 425 { 426 int c; 427 symbolS *symbolP; 428 429 do 430 { 431 symbolP = get_sym_from_input_line_and_check (); 432 c = *input_line_pointer; 433 S_CLEAR_EXTERNAL (symbolP); 434 symbol_get_obj (symbolP)->local = 1; 435 if (c == ',') 436 { 437 input_line_pointer++; 438 SKIP_WHITESPACE (); 439 if (*input_line_pointer == '\n') 440 c = '\n'; 441 } 442 } 443 while (c == ','); 444 demand_empty_rest_of_line (); 445 } 446 447 static void 448 obj_elf_weak (int ignore ATTRIBUTE_UNUSED) 449 { 450 int c; 451 symbolS *symbolP; 452 453 do 454 { 455 symbolP = get_sym_from_input_line_and_check (); 456 c = *input_line_pointer; 457 S_SET_WEAK (symbolP); 458 if (c == ',') 459 { 460 input_line_pointer++; 461 SKIP_WHITESPACE (); 462 if (*input_line_pointer == '\n') 463 c = '\n'; 464 } 465 } 466 while (c == ','); 467 demand_empty_rest_of_line (); 468 } 469 470 static void 471 obj_elf_visibility (int visibility) 472 { 473 int c; 474 symbolS *symbolP; 475 asymbol *bfdsym; 476 elf_symbol_type *elfsym; 477 478 do 479 { 480 symbolP = get_sym_from_input_line_and_check (); 481 482 bfdsym = symbol_get_bfdsym (symbolP); 483 elfsym = elf_symbol_from (bfd_asymbol_bfd (bfdsym), bfdsym); 484 485 gas_assert (elfsym); 486 487 elfsym->internal_elf_sym.st_other &= ~3; 488 elfsym->internal_elf_sym.st_other |= visibility; 489 490 c = *input_line_pointer; 491 if (c == ',') 492 { 493 input_line_pointer ++; 494 495 SKIP_WHITESPACE (); 496 497 if (*input_line_pointer == '\n') 498 c = '\n'; 499 } 500 } 501 while (c == ','); 502 503 demand_empty_rest_of_line (); 504 } 505 506 static segT previous_section; 507 static int previous_subsection; 508 509 struct section_stack 510 { 511 struct section_stack *next; 512 segT seg, prev_seg; 513 int subseg, prev_subseg; 514 }; 515 516 static struct section_stack *section_stack; 517 518 static bfd_boolean 519 get_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *inf) 520 { 521 const char *gname = (const char *) inf; 522 const char *group_name = elf_group_name (sec); 523 524 return (group_name == gname 525 || (group_name != NULL 526 && gname != NULL 527 && strcmp (group_name, gname) == 0)); 528 } 529 530 /* Handle the .section pseudo-op. This code supports two different 531 syntaxes. 532 533 The first is found on Solaris, and looks like 534 .section ".sec1",#alloc,#execinstr,#write 535 Here the names after '#' are the SHF_* flags to turn on for the 536 section. I'm not sure how it determines the SHT_* type (BFD 537 doesn't really give us control over the type, anyhow). 538 539 The second format is found on UnixWare, and probably most SVR4 540 machines, and looks like 541 .section .sec1,"a",@progbits 542 The quoted string may contain any combination of a, w, x, and 543 represents the SHF_* flags to turn on for the section. The string 544 beginning with '@' can be progbits or nobits. There should be 545 other possibilities, but I don't know what they are. In any case, 546 BFD doesn't really let us set the section type. */ 547 548 void 549 obj_elf_change_section (const char *name, 550 int type, 551 bfd_vma attr, 552 int entsize, 553 const char *group_name, 554 int linkonce, 555 int push) 556 { 557 asection *old_sec; 558 segT sec; 559 flagword flags; 560 const struct elf_backend_data *bed; 561 const struct bfd_elf_special_section *ssect; 562 563 #ifdef md_flush_pending_output 564 md_flush_pending_output (); 565 #endif 566 567 /* Switch to the section, creating it if necessary. */ 568 if (push) 569 { 570 struct section_stack *elt; 571 elt = (struct section_stack *) xmalloc (sizeof (struct section_stack)); 572 elt->next = section_stack; 573 elt->seg = now_seg; 574 elt->prev_seg = previous_section; 575 elt->subseg = now_subseg; 576 elt->prev_subseg = previous_subsection; 577 section_stack = elt; 578 } 579 previous_section = now_seg; 580 previous_subsection = now_subseg; 581 582 old_sec = bfd_get_section_by_name_if (stdoutput, name, get_section, 583 (void *) group_name); 584 if (old_sec) 585 { 586 sec = old_sec; 587 subseg_set (sec, 0); 588 } 589 else 590 sec = subseg_force_new (name, 0); 591 592 bed = get_elf_backend_data (stdoutput); 593 ssect = (*bed->get_sec_type_attr) (stdoutput, sec); 594 595 if (ssect != NULL) 596 { 597 bfd_boolean override = FALSE; 598 599 if (type == SHT_NULL) 600 type = ssect->type; 601 else if (type != ssect->type) 602 { 603 if (old_sec == NULL 604 /* Some older versions of gcc will emit 605 606 .section .init_array,"aw",@progbits 607 608 for __attribute__ ((section (".init_array"))). 609 "@progbits" is incorrect. Also for x86-64 large bss 610 sections, some older versions of gcc will emit 611 612 .section .lbss,"aw",@progbits 613 614 "@progbits" is incorrect. */ 615 #ifdef TC_I386 616 && (bed->s->arch_size != 64 617 || !(ssect->attr & SHF_X86_64_LARGE)) 618 #endif 619 && ssect->type != SHT_INIT_ARRAY 620 && ssect->type != SHT_FINI_ARRAY 621 && ssect->type != SHT_PREINIT_ARRAY) 622 { 623 /* We allow to specify any type for a .note section. */ 624 if (ssect->type != SHT_NOTE) 625 as_warn (_("setting incorrect section type for %s"), 626 name); 627 } 628 else 629 { 630 as_warn (_("ignoring incorrect section type for %s"), 631 name); 632 type = ssect->type; 633 } 634 } 635 636 if (old_sec == NULL && (attr & ~ssect->attr) != 0) 637 { 638 /* As a GNU extension, we permit a .note section to be 639 allocatable. If the linker sees an allocatable .note 640 section, it will create a PT_NOTE segment in the output 641 file. We also allow "x" for .note.GNU-stack. */ 642 if (ssect->type == SHT_NOTE 643 && (attr == SHF_ALLOC || attr == SHF_EXECINSTR)) 644 ; 645 /* Allow different SHF_MERGE and SHF_STRINGS if we have 646 something like .rodata.str. */ 647 else if (ssect->suffix_length == -2 648 && name[ssect->prefix_length] == '.' 649 && (attr 650 & ~ssect->attr 651 & ~SHF_MERGE 652 & ~SHF_STRINGS) == 0) 653 ; 654 /* .interp, .strtab and .symtab can have SHF_ALLOC. */ 655 else if (attr == SHF_ALLOC 656 && (strcmp (name, ".interp") == 0 657 || strcmp (name, ".strtab") == 0 658 || strcmp (name, ".symtab") == 0)) 659 override = TRUE; 660 /* .note.GNU-stack can have SHF_EXECINSTR. */ 661 else if (attr == SHF_EXECINSTR 662 && strcmp (name, ".note.GNU-stack") == 0) 663 override = TRUE; 664 #ifdef TC_ALPHA 665 /* A section on Alpha may have SHF_ALPHA_GPREL. */ 666 else if ((attr & ~ssect->attr) == SHF_ALPHA_GPREL) 667 override = TRUE; 668 #endif 669 #ifdef TC_RX 670 else if (attr == (SHF_EXECINSTR | SHF_WRITE | SHF_ALLOC) 671 && (ssect->type == SHT_INIT_ARRAY 672 || ssect->type == SHT_FINI_ARRAY 673 || ssect->type == SHT_PREINIT_ARRAY)) 674 /* RX init/fini arrays can and should have the "awx" attributes set. */ 675 ; 676 #endif 677 else 678 { 679 if (group_name == NULL) 680 as_warn (_("setting incorrect section attributes for %s"), 681 name); 682 override = TRUE; 683 } 684 } 685 if (!override && old_sec == NULL) 686 attr |= ssect->attr; 687 } 688 689 /* Convert ELF type and flags to BFD flags. */ 690 flags = (SEC_RELOC 691 | ((attr & SHF_WRITE) ? 0 : SEC_READONLY) 692 | ((attr & SHF_ALLOC) ? SEC_ALLOC : 0) 693 | (((attr & SHF_ALLOC) && type != SHT_NOBITS) ? SEC_LOAD : 0) 694 | ((attr & SHF_EXECINSTR) ? SEC_CODE : 0) 695 | ((attr & SHF_MERGE) ? SEC_MERGE : 0) 696 | ((attr & SHF_STRINGS) ? SEC_STRINGS : 0) 697 | ((attr & SHF_EXCLUDE) ? SEC_EXCLUDE: 0) 698 | ((attr & SHF_TLS) ? SEC_THREAD_LOCAL : 0)); 699 #ifdef md_elf_section_flags 700 flags = md_elf_section_flags (flags, attr, type); 701 #endif 702 703 if (linkonce) 704 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD; 705 706 if (old_sec == NULL) 707 { 708 symbolS *secsym; 709 710 if (type == SHT_NULL) 711 type = bfd_elf_get_default_section_type (flags); 712 elf_section_type (sec) = type; 713 elf_section_flags (sec) = attr; 714 715 /* Prevent SEC_HAS_CONTENTS from being inadvertently set. */ 716 if (type == SHT_NOBITS) 717 seg_info (sec)->bss = 1; 718 719 bfd_set_section_flags (stdoutput, sec, flags); 720 if (flags & SEC_MERGE) 721 sec->entsize = entsize; 722 elf_group_name (sec) = group_name; 723 724 /* Add a symbol for this section to the symbol table. */ 725 secsym = symbol_find (name); 726 if (secsym != NULL) 727 symbol_set_bfdsym (secsym, sec->symbol); 728 else 729 symbol_table_insert (section_symbol (sec)); 730 } 731 else 732 { 733 if (type != SHT_NULL 734 && (unsigned) type != elf_section_type (old_sec)) 735 as_warn (_("ignoring changed section type for %s"), name); 736 737 if (attr != 0) 738 { 739 /* If section attributes are specified the second time we see a 740 particular section, then check that they are the same as we 741 saw the first time. */ 742 if (((old_sec->flags ^ flags) 743 & (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE 744 | SEC_EXCLUDE | SEC_SORT_ENTRIES | SEC_MERGE | SEC_STRINGS 745 | SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD 746 | SEC_THREAD_LOCAL))) 747 as_warn (_("ignoring changed section attributes for %s"), name); 748 if ((flags & SEC_MERGE) && old_sec->entsize != (unsigned) entsize) 749 as_warn (_("ignoring changed section entity size for %s"), name); 750 } 751 } 752 753 #ifdef md_elf_section_change_hook 754 md_elf_section_change_hook (); 755 #endif 756 } 757 758 static bfd_vma 759 obj_elf_parse_section_letters (char *str, size_t len, bfd_boolean *is_clone) 760 { 761 bfd_vma attr = 0; 762 *is_clone = FALSE; 763 764 while (len > 0) 765 { 766 switch (*str) 767 { 768 case 'a': 769 attr |= SHF_ALLOC; 770 break; 771 case 'e': 772 attr |= SHF_EXCLUDE; 773 break; 774 case 'w': 775 attr |= SHF_WRITE; 776 break; 777 case 'x': 778 attr |= SHF_EXECINSTR; 779 break; 780 case 'M': 781 attr |= SHF_MERGE; 782 break; 783 case 'S': 784 attr |= SHF_STRINGS; 785 break; 786 case 'G': 787 attr |= SHF_GROUP; 788 break; 789 case 'T': 790 attr |= SHF_TLS; 791 break; 792 case '?': 793 *is_clone = TRUE; 794 break; 795 /* Compatibility. */ 796 case 'm': 797 if (*(str - 1) == 'a') 798 { 799 attr |= SHF_MERGE; 800 if (len > 1 && str[1] == 's') 801 { 802 attr |= SHF_STRINGS; 803 str++, len--; 804 } 805 break; 806 } 807 default: 808 { 809 char *bad_msg = _("unrecognized .section attribute: want a,e,w,x,M,S,G,T"); 810 #ifdef md_elf_section_letter 811 bfd_vma md_attr = md_elf_section_letter (*str, &bad_msg); 812 if (md_attr != (bfd_vma) -1) 813 attr |= md_attr; 814 else 815 #endif 816 as_fatal ("%s", bad_msg); 817 } 818 break; 819 } 820 str++, len--; 821 } 822 823 return attr; 824 } 825 826 static int 827 obj_elf_section_type (char *str, size_t len, bfd_boolean warn) 828 { 829 if (len == 8 && strncmp (str, "progbits", 8) == 0) 830 return SHT_PROGBITS; 831 if (len == 6 && strncmp (str, "nobits", 6) == 0) 832 return SHT_NOBITS; 833 if (len == 4 && strncmp (str, "note", 4) == 0) 834 return SHT_NOTE; 835 if (len == 10 && strncmp (str, "init_array", 10) == 0) 836 return SHT_INIT_ARRAY; 837 if (len == 10 && strncmp (str, "fini_array", 10) == 0) 838 return SHT_FINI_ARRAY; 839 if (len == 13 && strncmp (str, "preinit_array", 13) == 0) 840 return SHT_PREINIT_ARRAY; 841 842 #ifdef md_elf_section_type 843 { 844 int md_type = md_elf_section_type (str, len); 845 if (md_type >= 0) 846 return md_type; 847 } 848 #endif 849 850 if (warn) 851 as_warn (_("unrecognized section type")); 852 return 0; 853 } 854 855 static bfd_vma 856 obj_elf_section_word (char *str, size_t len, int *type) 857 { 858 int ret; 859 860 if (len == 5 && strncmp (str, "write", 5) == 0) 861 return SHF_WRITE; 862 if (len == 5 && strncmp (str, "alloc", 5) == 0) 863 return SHF_ALLOC; 864 if (len == 9 && strncmp (str, "execinstr", 9) == 0) 865 return SHF_EXECINSTR; 866 if (len == 7 && strncmp (str, "exclude", 7) == 0) 867 return SHF_EXCLUDE; 868 if (len == 3 && strncmp (str, "tls", 3) == 0) 869 return SHF_TLS; 870 871 #ifdef md_elf_section_word 872 { 873 bfd_vma md_attr = md_elf_section_word (str, len); 874 if (md_attr > 0) 875 return md_attr; 876 } 877 #endif 878 879 ret = obj_elf_section_type (str, len, FALSE); 880 if (ret != 0) 881 *type = ret; 882 else 883 as_warn (_("unrecognized section attribute")); 884 885 return 0; 886 } 887 888 /* Get name of section. */ 889 char * 890 obj_elf_section_name (void) 891 { 892 char *name; 893 894 SKIP_WHITESPACE (); 895 if (*input_line_pointer == '"') 896 { 897 int dummy; 898 899 name = demand_copy_C_string (&dummy); 900 if (name == NULL) 901 { 902 ignore_rest_of_line (); 903 return NULL; 904 } 905 } 906 else 907 { 908 char *end = input_line_pointer; 909 910 while (0 == strchr ("\n\t,; ", *end)) 911 end++; 912 if (end == input_line_pointer) 913 { 914 as_bad (_("missing name")); 915 ignore_rest_of_line (); 916 return NULL; 917 } 918 919 name = (char *) xmalloc (end - input_line_pointer + 1); 920 memcpy (name, input_line_pointer, end - input_line_pointer); 921 name[end - input_line_pointer] = '\0'; 922 #ifdef tc_canonicalize_section_name 923 name = tc_canonicalize_section_name (name); 924 #endif 925 input_line_pointer = end; 926 } 927 SKIP_WHITESPACE (); 928 return name; 929 } 930 931 void 932 obj_elf_section (int push) 933 { 934 char *name, *group_name, *beg; 935 int type, dummy; 936 bfd_vma attr; 937 int entsize; 938 int linkonce; 939 subsegT new_subsection = -1; 940 941 #ifndef TC_I370 942 if (flag_mri) 943 { 944 char mri_type; 945 946 #ifdef md_flush_pending_output 947 md_flush_pending_output (); 948 #endif 949 950 previous_section = now_seg; 951 previous_subsection = now_subseg; 952 953 s_mri_sect (&mri_type); 954 955 #ifdef md_elf_section_change_hook 956 md_elf_section_change_hook (); 957 #endif 958 959 return; 960 } 961 #endif /* ! defined (TC_I370) */ 962 963 name = obj_elf_section_name (); 964 if (name == NULL) 965 return; 966 type = SHT_NULL; 967 attr = 0; 968 group_name = NULL; 969 entsize = 0; 970 linkonce = 0; 971 972 if (*input_line_pointer == ',') 973 { 974 /* Skip the comma. */ 975 ++input_line_pointer; 976 SKIP_WHITESPACE (); 977 978 if (push && ISDIGIT (*input_line_pointer)) 979 { 980 /* .pushsection has an optional subsection. */ 981 new_subsection = (subsegT) get_absolute_expression (); 982 983 SKIP_WHITESPACE (); 984 985 /* Stop if we don't see a comma. */ 986 if (*input_line_pointer != ',') 987 goto done; 988 989 /* Skip the comma. */ 990 ++input_line_pointer; 991 SKIP_WHITESPACE (); 992 } 993 994 if (*input_line_pointer == '"') 995 { 996 bfd_boolean is_clone; 997 998 beg = demand_copy_C_string (&dummy); 999 if (beg == NULL) 1000 { 1001 ignore_rest_of_line (); 1002 return; 1003 } 1004 attr |= obj_elf_parse_section_letters (beg, strlen (beg), &is_clone); 1005 1006 SKIP_WHITESPACE (); 1007 if (*input_line_pointer == ',') 1008 { 1009 char c; 1010 char *save = input_line_pointer; 1011 1012 ++input_line_pointer; 1013 SKIP_WHITESPACE (); 1014 c = *input_line_pointer; 1015 if (c == '"') 1016 { 1017 beg = demand_copy_C_string (&dummy); 1018 if (beg == NULL) 1019 { 1020 ignore_rest_of_line (); 1021 return; 1022 } 1023 type = obj_elf_section_type (beg, strlen (beg), TRUE); 1024 } 1025 else if (c == '@' || c == '%') 1026 { 1027 beg = ++input_line_pointer; 1028 c = get_symbol_end (); 1029 *input_line_pointer = c; 1030 type = obj_elf_section_type (beg, input_line_pointer - beg, TRUE); 1031 } 1032 else 1033 input_line_pointer = save; 1034 } 1035 1036 SKIP_WHITESPACE (); 1037 if ((attr & SHF_MERGE) != 0 && *input_line_pointer == ',') 1038 { 1039 ++input_line_pointer; 1040 SKIP_WHITESPACE (); 1041 entsize = get_absolute_expression (); 1042 SKIP_WHITESPACE (); 1043 if (entsize < 0) 1044 { 1045 as_warn (_("invalid merge entity size")); 1046 attr &= ~SHF_MERGE; 1047 entsize = 0; 1048 } 1049 } 1050 else if ((attr & SHF_MERGE) != 0) 1051 { 1052 as_warn (_("entity size for SHF_MERGE not specified")); 1053 attr &= ~SHF_MERGE; 1054 } 1055 1056 if ((attr & SHF_GROUP) != 0 && is_clone) 1057 { 1058 as_warn (_("? section flag ignored with G present")); 1059 is_clone = FALSE; 1060 } 1061 if ((attr & SHF_GROUP) != 0 && *input_line_pointer == ',') 1062 { 1063 ++input_line_pointer; 1064 group_name = obj_elf_section_name (); 1065 if (group_name == NULL) 1066 attr &= ~SHF_GROUP; 1067 else if (*input_line_pointer == ',') 1068 { 1069 ++input_line_pointer; 1070 SKIP_WHITESPACE (); 1071 if (strncmp (input_line_pointer, "comdat", 6) == 0) 1072 { 1073 input_line_pointer += 6; 1074 linkonce = 1; 1075 } 1076 } 1077 else if (strncmp (name, ".gnu.linkonce", 13) == 0) 1078 linkonce = 1; 1079 } 1080 else if ((attr & SHF_GROUP) != 0) 1081 { 1082 as_warn (_("group name for SHF_GROUP not specified")); 1083 attr &= ~SHF_GROUP; 1084 } 1085 1086 if (is_clone) 1087 { 1088 const char *now_group = elf_group_name (now_seg); 1089 if (now_group != NULL) 1090 { 1091 group_name = xstrdup (now_group); 1092 linkonce = (now_seg->flags & SEC_LINK_ONCE) != 0; 1093 } 1094 } 1095 } 1096 else 1097 { 1098 do 1099 { 1100 char c; 1101 1102 SKIP_WHITESPACE (); 1103 if (*input_line_pointer != '#') 1104 { 1105 as_bad (_("character following name is not '#'")); 1106 ignore_rest_of_line (); 1107 return; 1108 } 1109 beg = ++input_line_pointer; 1110 c = get_symbol_end (); 1111 *input_line_pointer = c; 1112 1113 attr |= obj_elf_section_word (beg, input_line_pointer - beg, & type); 1114 1115 SKIP_WHITESPACE (); 1116 } 1117 while (*input_line_pointer++ == ','); 1118 --input_line_pointer; 1119 } 1120 } 1121 1122 done: 1123 demand_empty_rest_of_line (); 1124 1125 obj_elf_change_section (name, type, attr, entsize, group_name, linkonce, push); 1126 1127 if (push && new_subsection != -1) 1128 subseg_set (now_seg, new_subsection); 1129 } 1130 1131 /* Change to the .data section. */ 1132 1133 void 1134 obj_elf_data (int i) 1135 { 1136 #ifdef md_flush_pending_output 1137 md_flush_pending_output (); 1138 #endif 1139 1140 previous_section = now_seg; 1141 previous_subsection = now_subseg; 1142 s_data (i); 1143 1144 #ifdef md_elf_section_change_hook 1145 md_elf_section_change_hook (); 1146 #endif 1147 } 1148 1149 /* Change to the .text section. */ 1150 1151 void 1152 obj_elf_text (int i) 1153 { 1154 #ifdef md_flush_pending_output 1155 md_flush_pending_output (); 1156 #endif 1157 1158 previous_section = now_seg; 1159 previous_subsection = now_subseg; 1160 s_text (i); 1161 1162 #ifdef md_elf_section_change_hook 1163 md_elf_section_change_hook (); 1164 #endif 1165 } 1166 1167 /* Change to the *ABS* section. */ 1168 1169 void 1170 obj_elf_struct (int i) 1171 { 1172 #ifdef md_flush_pending_output 1173 md_flush_pending_output (); 1174 #endif 1175 1176 previous_section = now_seg; 1177 previous_subsection = now_subseg; 1178 s_struct (i); 1179 1180 #ifdef md_elf_section_change_hook 1181 md_elf_section_change_hook (); 1182 #endif 1183 } 1184 1185 static void 1186 obj_elf_subsection (int ignore ATTRIBUTE_UNUSED) 1187 { 1188 int temp; 1189 1190 #ifdef md_flush_pending_output 1191 md_flush_pending_output (); 1192 #endif 1193 1194 previous_section = now_seg; 1195 previous_subsection = now_subseg; 1196 1197 temp = get_absolute_expression (); 1198 subseg_set (now_seg, (subsegT) temp); 1199 demand_empty_rest_of_line (); 1200 1201 #ifdef md_elf_section_change_hook 1202 md_elf_section_change_hook (); 1203 #endif 1204 } 1205 1206 /* This can be called from the processor backends if they change 1207 sections. */ 1208 1209 void 1210 obj_elf_section_change_hook (void) 1211 { 1212 previous_section = now_seg; 1213 previous_subsection = now_subseg; 1214 } 1215 1216 void 1217 obj_elf_previous (int ignore ATTRIBUTE_UNUSED) 1218 { 1219 segT new_section; 1220 int new_subsection; 1221 1222 if (previous_section == 0) 1223 { 1224 as_warn (_(".previous without corresponding .section; ignored")); 1225 return; 1226 } 1227 1228 #ifdef md_flush_pending_output 1229 md_flush_pending_output (); 1230 #endif 1231 1232 new_section = previous_section; 1233 new_subsection = previous_subsection; 1234 previous_section = now_seg; 1235 previous_subsection = now_subseg; 1236 subseg_set (new_section, new_subsection); 1237 1238 #ifdef md_elf_section_change_hook 1239 md_elf_section_change_hook (); 1240 #endif 1241 } 1242 1243 static void 1244 obj_elf_popsection (int xxx ATTRIBUTE_UNUSED) 1245 { 1246 struct section_stack *top = section_stack; 1247 1248 if (top == NULL) 1249 { 1250 as_warn (_(".popsection without corresponding .pushsection; ignored")); 1251 return; 1252 } 1253 1254 #ifdef md_flush_pending_output 1255 md_flush_pending_output (); 1256 #endif 1257 1258 section_stack = top->next; 1259 previous_section = top->prev_seg; 1260 previous_subsection = top->prev_subseg; 1261 subseg_set (top->seg, top->subseg); 1262 free (top); 1263 1264 #ifdef md_elf_section_change_hook 1265 md_elf_section_change_hook (); 1266 #endif 1267 } 1268 1269 static void 1270 obj_elf_line (int ignore ATTRIBUTE_UNUSED) 1271 { 1272 /* Assume delimiter is part of expression. BSD4.2 as fails with 1273 delightful bug, so we are not being incompatible here. */ 1274 new_logical_line (NULL, get_absolute_expression ()); 1275 demand_empty_rest_of_line (); 1276 } 1277 1278 /* This handles the .symver pseudo-op, which is used to specify a 1279 symbol version. The syntax is ``.symver NAME,SYMVERNAME''. 1280 SYMVERNAME may contain ELF_VER_CHR ('@') characters. This 1281 pseudo-op causes the assembler to emit a symbol named SYMVERNAME 1282 with the same value as the symbol NAME. */ 1283 1284 static void 1285 obj_elf_symver (int ignore ATTRIBUTE_UNUSED) 1286 { 1287 char *name; 1288 char c; 1289 char old_lexat; 1290 symbolS *sym; 1291 1292 sym = get_sym_from_input_line_and_check (); 1293 1294 if (*input_line_pointer != ',') 1295 { 1296 as_bad (_("expected comma after name in .symver")); 1297 ignore_rest_of_line (); 1298 return; 1299 } 1300 1301 ++input_line_pointer; 1302 SKIP_WHITESPACE (); 1303 name = input_line_pointer; 1304 1305 /* Temporarily include '@' in symbol names. */ 1306 old_lexat = lex_type[(unsigned char) '@']; 1307 lex_type[(unsigned char) '@'] |= LEX_NAME; 1308 c = get_symbol_end (); 1309 lex_type[(unsigned char) '@'] = old_lexat; 1310 1311 if (symbol_get_obj (sym)->versioned_name == NULL) 1312 { 1313 symbol_get_obj (sym)->versioned_name = xstrdup (name); 1314 1315 *input_line_pointer = c; 1316 1317 if (strchr (symbol_get_obj (sym)->versioned_name, 1318 ELF_VER_CHR) == NULL) 1319 { 1320 as_bad (_("missing version name in `%s' for symbol `%s'"), 1321 symbol_get_obj (sym)->versioned_name, 1322 S_GET_NAME (sym)); 1323 ignore_rest_of_line (); 1324 return; 1325 } 1326 } 1327 else 1328 { 1329 if (strcmp (symbol_get_obj (sym)->versioned_name, name)) 1330 { 1331 as_bad (_("multiple versions [`%s'|`%s'] for symbol `%s'"), 1332 name, symbol_get_obj (sym)->versioned_name, 1333 S_GET_NAME (sym)); 1334 ignore_rest_of_line (); 1335 return; 1336 } 1337 1338 *input_line_pointer = c; 1339 } 1340 1341 demand_empty_rest_of_line (); 1342 } 1343 1344 /* This handles the .vtable_inherit pseudo-op, which is used to indicate 1345 to the linker the hierarchy in which a particular table resides. The 1346 syntax is ".vtable_inherit CHILDNAME, PARENTNAME". */ 1347 1348 struct fix * 1349 obj_elf_vtable_inherit (int ignore ATTRIBUTE_UNUSED) 1350 { 1351 char *cname, *pname; 1352 symbolS *csym, *psym; 1353 char c, bad = 0; 1354 1355 if (*input_line_pointer == '#') 1356 ++input_line_pointer; 1357 1358 cname = input_line_pointer; 1359 c = get_symbol_end (); 1360 csym = symbol_find (cname); 1361 1362 /* GCFIXME: should check that we don't have two .vtable_inherits for 1363 the same child symbol. Also, we can currently only do this if the 1364 child symbol is already exists and is placed in a fragment. */ 1365 1366 if (csym == NULL || symbol_get_frag (csym) == NULL) 1367 { 1368 as_bad (_("expected `%s' to have already been set for .vtable_inherit"), 1369 cname); 1370 bad = 1; 1371 } 1372 1373 *input_line_pointer = c; 1374 1375 SKIP_WHITESPACE (); 1376 if (*input_line_pointer != ',') 1377 { 1378 as_bad (_("expected comma after name in .vtable_inherit")); 1379 ignore_rest_of_line (); 1380 return NULL; 1381 } 1382 1383 ++input_line_pointer; 1384 SKIP_WHITESPACE (); 1385 1386 if (*input_line_pointer == '#') 1387 ++input_line_pointer; 1388 1389 if (input_line_pointer[0] == '0' 1390 && (input_line_pointer[1] == '\0' 1391 || ISSPACE (input_line_pointer[1]))) 1392 { 1393 psym = section_symbol (absolute_section); 1394 ++input_line_pointer; 1395 } 1396 else 1397 { 1398 pname = input_line_pointer; 1399 c = get_symbol_end (); 1400 psym = symbol_find_or_make (pname); 1401 *input_line_pointer = c; 1402 } 1403 1404 demand_empty_rest_of_line (); 1405 1406 if (bad) 1407 return NULL; 1408 1409 gas_assert (symbol_get_value_expression (csym)->X_op == O_constant); 1410 return fix_new (symbol_get_frag (csym), 1411 symbol_get_value_expression (csym)->X_add_number, 1412 0, psym, 0, 0, BFD_RELOC_VTABLE_INHERIT); 1413 } 1414 1415 /* This handles the .vtable_entry pseudo-op, which is used to indicate 1416 to the linker that a vtable slot was used. The syntax is 1417 ".vtable_entry tablename, offset". */ 1418 1419 struct fix * 1420 obj_elf_vtable_entry (int ignore ATTRIBUTE_UNUSED) 1421 { 1422 symbolS *sym; 1423 offsetT offset; 1424 1425 if (*input_line_pointer == '#') 1426 ++input_line_pointer; 1427 1428 sym = get_sym_from_input_line_and_check (); 1429 if (*input_line_pointer != ',') 1430 { 1431 as_bad (_("expected comma after name in .vtable_entry")); 1432 ignore_rest_of_line (); 1433 return NULL; 1434 } 1435 1436 ++input_line_pointer; 1437 if (*input_line_pointer == '#') 1438 ++input_line_pointer; 1439 1440 offset = get_absolute_expression (); 1441 1442 demand_empty_rest_of_line (); 1443 1444 return fix_new (frag_now, frag_now_fix (), 0, sym, offset, 0, 1445 BFD_RELOC_VTABLE_ENTRY); 1446 } 1447 1448 #define skip_whitespace(str) do { if (*(str) == ' ') ++(str); } while (0) 1449 1450 static inline int 1451 skip_past_char (char ** str, char c) 1452 { 1453 if (**str == c) 1454 { 1455 (*str)++; 1456 return 0; 1457 } 1458 else 1459 return -1; 1460 } 1461 #define skip_past_comma(str) skip_past_char (str, ',') 1462 1463 /* A list of attributes that have been explicitly set by the assembly code. 1464 VENDOR is the vendor id, BASE is the tag shifted right by the number 1465 of bits in MASK, and bit N of MASK is set if tag BASE+N has been set. */ 1466 struct recorded_attribute_info { 1467 struct recorded_attribute_info *next; 1468 int vendor; 1469 unsigned int base; 1470 unsigned long mask; 1471 }; 1472 static struct recorded_attribute_info *recorded_attributes; 1473 1474 /* Record that we have seen an explicit specification of attribute TAG 1475 for vendor VENDOR. */ 1476 1477 static void 1478 record_attribute (int vendor, unsigned int tag) 1479 { 1480 unsigned int base; 1481 unsigned long mask; 1482 struct recorded_attribute_info *rai; 1483 1484 base = tag / (8 * sizeof (rai->mask)); 1485 mask = 1UL << (tag % (8 * sizeof (rai->mask))); 1486 for (rai = recorded_attributes; rai; rai = rai->next) 1487 if (rai->vendor == vendor && rai->base == base) 1488 { 1489 rai->mask |= mask; 1490 return; 1491 } 1492 1493 rai = XNEW (struct recorded_attribute_info); 1494 rai->next = recorded_attributes; 1495 rai->vendor = vendor; 1496 rai->base = base; 1497 rai->mask = mask; 1498 recorded_attributes = rai; 1499 } 1500 1501 /* Return true if we have seen an explicit specification of attribute TAG 1502 for vendor VENDOR. */ 1503 1504 bfd_boolean 1505 obj_elf_seen_attribute (int vendor, unsigned int tag) 1506 { 1507 unsigned int base; 1508 unsigned long mask; 1509 struct recorded_attribute_info *rai; 1510 1511 base = tag / (8 * sizeof (rai->mask)); 1512 mask = 1UL << (tag % (8 * sizeof (rai->mask))); 1513 for (rai = recorded_attributes; rai; rai = rai->next) 1514 if (rai->vendor == vendor && rai->base == base) 1515 return (rai->mask & mask) != 0; 1516 return FALSE; 1517 } 1518 1519 /* Parse an attribute directive for VENDOR. 1520 Returns the attribute number read, or zero on error. */ 1521 1522 int 1523 obj_elf_vendor_attribute (int vendor) 1524 { 1525 expressionS exp; 1526 int type; 1527 int tag; 1528 unsigned int i = 0; 1529 char *s = NULL; 1530 1531 /* Read the first number or name. */ 1532 skip_whitespace (input_line_pointer); 1533 s = input_line_pointer; 1534 if (ISDIGIT (*input_line_pointer)) 1535 { 1536 expression (& exp); 1537 if (exp.X_op != O_constant) 1538 goto bad; 1539 tag = exp.X_add_number; 1540 } 1541 else 1542 { 1543 char *name; 1544 1545 /* A name may contain '_', but no other punctuation. */ 1546 for (; ISALNUM (*input_line_pointer) || *input_line_pointer == '_'; 1547 ++input_line_pointer) 1548 i++; 1549 if (i == 0) 1550 goto bad; 1551 1552 name = (char *) alloca (i + 1); 1553 memcpy (name, s, i); 1554 name[i] = '\0'; 1555 1556 #ifndef CONVERT_SYMBOLIC_ATTRIBUTE 1557 #define CONVERT_SYMBOLIC_ATTRIBUTE(a) -1 1558 #endif 1559 1560 tag = CONVERT_SYMBOLIC_ATTRIBUTE (name); 1561 if (tag == -1) 1562 { 1563 as_bad (_("Attribute name not recognised: %s"), name); 1564 ignore_rest_of_line (); 1565 return 0; 1566 } 1567 } 1568 1569 type = _bfd_elf_obj_attrs_arg_type (stdoutput, vendor, tag); 1570 1571 if (skip_past_comma (&input_line_pointer) == -1) 1572 goto bad; 1573 if (type & 1) 1574 { 1575 expression (& exp); 1576 if (exp.X_op != O_constant) 1577 { 1578 as_bad (_("expected numeric constant")); 1579 ignore_rest_of_line (); 1580 return 0; 1581 } 1582 i = exp.X_add_number; 1583 } 1584 if ((type & 3) == 3 1585 && skip_past_comma (&input_line_pointer) == -1) 1586 { 1587 as_bad (_("expected comma")); 1588 ignore_rest_of_line (); 1589 return 0; 1590 } 1591 if (type & 2) 1592 { 1593 int len; 1594 1595 skip_whitespace (input_line_pointer); 1596 if (*input_line_pointer != '"') 1597 goto bad_string; 1598 s = demand_copy_C_string (&len); 1599 } 1600 1601 record_attribute (vendor, tag); 1602 switch (type & 3) 1603 { 1604 case 3: 1605 bfd_elf_add_obj_attr_int_string (stdoutput, vendor, tag, i, s); 1606 break; 1607 case 2: 1608 bfd_elf_add_obj_attr_string (stdoutput, vendor, tag, s); 1609 break; 1610 case 1: 1611 bfd_elf_add_obj_attr_int (stdoutput, vendor, tag, i); 1612 break; 1613 default: 1614 abort (); 1615 } 1616 1617 demand_empty_rest_of_line (); 1618 return tag; 1619 bad_string: 1620 as_bad (_("bad string constant")); 1621 ignore_rest_of_line (); 1622 return 0; 1623 bad: 1624 as_bad (_("expected <tag> , <value>")); 1625 ignore_rest_of_line (); 1626 return 0; 1627 } 1628 1629 /* Parse a .gnu_attribute directive. */ 1630 1631 static void 1632 obj_elf_gnu_attribute (int ignored ATTRIBUTE_UNUSED) 1633 { 1634 obj_elf_vendor_attribute (OBJ_ATTR_GNU); 1635 } 1636 1637 void 1638 elf_obj_read_begin_hook (void) 1639 { 1640 #ifdef NEED_ECOFF_DEBUG 1641 if (ECOFF_DEBUGGING) 1642 ecoff_read_begin_hook (); 1643 #endif 1644 } 1645 1646 void 1647 elf_obj_symbol_new_hook (symbolS *symbolP) 1648 { 1649 struct elf_obj_sy *sy_obj; 1650 1651 sy_obj = symbol_get_obj (symbolP); 1652 sy_obj->size = NULL; 1653 sy_obj->versioned_name = NULL; 1654 1655 #ifdef NEED_ECOFF_DEBUG 1656 if (ECOFF_DEBUGGING) 1657 ecoff_symbol_new_hook (symbolP); 1658 #endif 1659 } 1660 1661 /* When setting one symbol equal to another, by default we probably 1662 want them to have the same "size", whatever it means in the current 1663 context. */ 1664 1665 void 1666 elf_copy_symbol_attributes (symbolS *dest, symbolS *src) 1667 { 1668 struct elf_obj_sy *srcelf = symbol_get_obj (src); 1669 struct elf_obj_sy *destelf = symbol_get_obj (dest); 1670 if (srcelf->size) 1671 { 1672 if (destelf->size == NULL) 1673 destelf->size = (expressionS *) xmalloc (sizeof (expressionS)); 1674 *destelf->size = *srcelf->size; 1675 } 1676 else 1677 { 1678 if (destelf->size != NULL) 1679 free (destelf->size); 1680 destelf->size = NULL; 1681 } 1682 S_SET_SIZE (dest, S_GET_SIZE (src)); 1683 /* Don't copy visibility. */ 1684 S_SET_OTHER (dest, (ELF_ST_VISIBILITY (S_GET_OTHER (dest)) 1685 | (S_GET_OTHER (src) & ~ELF_ST_VISIBILITY (-1)))); 1686 } 1687 1688 void 1689 obj_elf_version (int ignore ATTRIBUTE_UNUSED) 1690 { 1691 char *name; 1692 unsigned int c; 1693 char *p; 1694 asection *seg = now_seg; 1695 subsegT subseg = now_subseg; 1696 Elf_Internal_Note i_note; 1697 Elf_External_Note e_note; 1698 asection *note_secp = NULL; 1699 1700 SKIP_WHITESPACE (); 1701 if (*input_line_pointer == '\"') 1702 { 1703 unsigned int len; 1704 1705 ++input_line_pointer; /* -> 1st char of string. */ 1706 name = input_line_pointer; 1707 1708 while (is_a_char (c = next_char_of_string ())) 1709 ; 1710 c = *input_line_pointer; 1711 *input_line_pointer = '\0'; 1712 *(input_line_pointer - 1) = '\0'; 1713 *input_line_pointer = c; 1714 1715 /* Create the .note section. */ 1716 note_secp = subseg_new (".note", 0); 1717 bfd_set_section_flags (stdoutput, 1718 note_secp, 1719 SEC_HAS_CONTENTS | SEC_READONLY); 1720 1721 /* Process the version string. */ 1722 len = strlen (name) + 1; 1723 1724 /* PR 3456: Although the name field is padded out to an 4-byte 1725 boundary, the namesz field should not be adjusted. */ 1726 i_note.namesz = len; 1727 i_note.descsz = 0; /* No description. */ 1728 i_note.type = NT_VERSION; 1729 p = frag_more (sizeof (e_note.namesz)); 1730 md_number_to_chars (p, i_note.namesz, sizeof (e_note.namesz)); 1731 p = frag_more (sizeof (e_note.descsz)); 1732 md_number_to_chars (p, i_note.descsz, sizeof (e_note.descsz)); 1733 p = frag_more (sizeof (e_note.type)); 1734 md_number_to_chars (p, i_note.type, sizeof (e_note.type)); 1735 p = frag_more (len); 1736 memcpy (p, name, len); 1737 1738 frag_align (2, 0, 0); 1739 1740 subseg_set (seg, subseg); 1741 } 1742 else 1743 as_bad (_("expected quoted string")); 1744 1745 demand_empty_rest_of_line (); 1746 } 1747 1748 static void 1749 obj_elf_size (int ignore ATTRIBUTE_UNUSED) 1750 { 1751 char *name = input_line_pointer; 1752 char c = get_symbol_end (); 1753 char *p; 1754 expressionS exp; 1755 symbolS *sym; 1756 1757 p = input_line_pointer; 1758 *p = c; 1759 SKIP_WHITESPACE (); 1760 if (*input_line_pointer != ',') 1761 { 1762 *p = 0; 1763 as_bad (_("expected comma after name `%s' in .size directive"), name); 1764 *p = c; 1765 ignore_rest_of_line (); 1766 return; 1767 } 1768 input_line_pointer++; 1769 expression (&exp); 1770 if (exp.X_op == O_absent) 1771 { 1772 as_bad (_("missing expression in .size directive")); 1773 exp.X_op = O_constant; 1774 exp.X_add_number = 0; 1775 } 1776 *p = 0; 1777 sym = symbol_find_or_make (name); 1778 *p = c; 1779 if (exp.X_op == O_constant) 1780 { 1781 S_SET_SIZE (sym, exp.X_add_number); 1782 if (symbol_get_obj (sym)->size) 1783 { 1784 xfree (symbol_get_obj (sym)->size); 1785 symbol_get_obj (sym)->size = NULL; 1786 } 1787 } 1788 else 1789 { 1790 symbol_get_obj (sym)->size = 1791 (expressionS *) xmalloc (sizeof (expressionS)); 1792 *symbol_get_obj (sym)->size = exp; 1793 } 1794 demand_empty_rest_of_line (); 1795 } 1796 1797 /* Handle the ELF .type pseudo-op. This sets the type of a symbol. 1798 There are six syntaxes: 1799 1800 The first (used on Solaris) is 1801 .type SYM,#function 1802 The second (used on UnixWare) is 1803 .type SYM,@function 1804 The third (reportedly to be used on Irix 6.0) is 1805 .type SYM STT_FUNC 1806 The fourth (used on NetBSD/Arm and Linux/ARM) is 1807 .type SYM,%function 1808 The fifth (used on SVR4/860) is 1809 .type SYM,"function" 1810 The sixth (emitted by recent SunPRO under Solaris) is 1811 .type SYM,[0-9] 1812 where the integer is the STT_* value. 1813 */ 1814 1815 static char * 1816 obj_elf_type_name (char *cp) 1817 { 1818 char *p; 1819 1820 p = input_line_pointer; 1821 if (*input_line_pointer >= '0' 1822 && *input_line_pointer <= '9') 1823 { 1824 while (*input_line_pointer >= '0' 1825 && *input_line_pointer <= '9') 1826 ++input_line_pointer; 1827 *cp = *input_line_pointer; 1828 *input_line_pointer = '\0'; 1829 } 1830 else 1831 *cp = get_symbol_end (); 1832 1833 return p; 1834 } 1835 1836 static void 1837 obj_elf_type (int ignore ATTRIBUTE_UNUSED) 1838 { 1839 char c; 1840 int type; 1841 const char *type_name; 1842 symbolS *sym; 1843 elf_symbol_type *elfsym; 1844 1845 sym = get_sym_from_input_line_and_check (); 1846 c = *input_line_pointer; 1847 elfsym = (elf_symbol_type *) symbol_get_bfdsym (sym); 1848 1849 if (*input_line_pointer == ',') 1850 ++input_line_pointer; 1851 1852 SKIP_WHITESPACE (); 1853 if ( *input_line_pointer == '#' 1854 || *input_line_pointer == '@' 1855 || *input_line_pointer == '"' 1856 || *input_line_pointer == '%') 1857 ++input_line_pointer; 1858 1859 type_name = obj_elf_type_name (& c); 1860 1861 type = 0; 1862 if (strcmp (type_name, "function") == 0 1863 || strcmp (type_name, "2") == 0 1864 || strcmp (type_name, "STT_FUNC") == 0) 1865 type = BSF_FUNCTION; 1866 else if (strcmp (type_name, "object") == 0 1867 || strcmp (type_name, "1") == 0 1868 || strcmp (type_name, "STT_OBJECT") == 0) 1869 type = BSF_OBJECT; 1870 else if (strcmp (type_name, "tls_object") == 0 1871 || strcmp (type_name, "6") == 0 1872 || strcmp (type_name, "STT_TLS") == 0) 1873 type = BSF_OBJECT | BSF_THREAD_LOCAL; 1874 else if (strcmp (type_name, "notype") == 0 1875 || strcmp (type_name, "0") == 0 1876 || strcmp (type_name, "STT_NOTYPE") == 0) 1877 ; 1878 else if (strcmp (type_name, "common") == 0 1879 || strcmp (type_name, "5") == 0 1880 || strcmp (type_name, "STT_COMMON") == 0) 1881 { 1882 type = BSF_OBJECT; 1883 1884 if (! S_IS_COMMON (sym)) 1885 { 1886 if (S_IS_VOLATILE (sym)) 1887 { 1888 sym = symbol_clone (sym, 1); 1889 S_SET_SEGMENT (sym, bfd_com_section_ptr); 1890 S_SET_VALUE (sym, 0); 1891 S_SET_EXTERNAL (sym); 1892 symbol_set_frag (sym, &zero_address_frag); 1893 S_CLEAR_VOLATILE (sym); 1894 } 1895 else if (S_IS_DEFINED (sym) || symbol_equated_p (sym)) 1896 as_bad (_("symbol '%s' is already defined"), S_GET_NAME (sym)); 1897 else 1898 { 1899 /* FIXME: Is it safe to just change the section ? */ 1900 S_SET_SEGMENT (sym, bfd_com_section_ptr); 1901 S_SET_VALUE (sym, 0); 1902 S_SET_EXTERNAL (sym); 1903 } 1904 } 1905 } 1906 else if (strcmp (type_name, "gnu_indirect_function") == 0 1907 || strcmp (type_name, "10") == 0 1908 || strcmp (type_name, "STT_GNU_IFUNC") == 0) 1909 { 1910 const struct elf_backend_data *bed; 1911 1912 bed = get_elf_backend_data (stdoutput); 1913 if (!(bed->elf_osabi == ELFOSABI_GNU 1914 || bed->elf_osabi == ELFOSABI_FREEBSD 1915 /* GNU is still using the default value 0. */ 1916 || bed->elf_osabi == ELFOSABI_NONE)) 1917 as_bad (_("symbol type \"%s\" is supported only by GNU and FreeBSD targets"), 1918 type_name); 1919 type = BSF_FUNCTION | BSF_GNU_INDIRECT_FUNCTION; 1920 } 1921 else if (strcmp (type_name, "gnu_unique_object") == 0) 1922 { 1923 struct elf_backend_data *bed; 1924 1925 bed = (struct elf_backend_data *) get_elf_backend_data (stdoutput); 1926 if (!(bed->elf_osabi == ELFOSABI_GNU 1927 /* GNU is still using the default value 0. */ 1928 || bed->elf_osabi == ELFOSABI_NONE)) 1929 as_bad (_("symbol type \"%s\" is supported only by GNU targets"), 1930 type_name); 1931 type = BSF_OBJECT | BSF_GNU_UNIQUE; 1932 /* PR 10549: Always set OSABI field to GNU for objects containing unique symbols. */ 1933 bed->elf_osabi = ELFOSABI_GNU; 1934 } 1935 #ifdef md_elf_symbol_type 1936 else if ((type = md_elf_symbol_type (type_name, sym, elfsym)) != -1) 1937 ; 1938 #endif 1939 else 1940 as_bad (_("unrecognized symbol type \"%s\""), type_name); 1941 1942 *input_line_pointer = c; 1943 1944 if (*input_line_pointer == '"') 1945 ++input_line_pointer; 1946 1947 elfsym->symbol.flags |= type; 1948 1949 demand_empty_rest_of_line (); 1950 } 1951 1952 static void 1953 obj_elf_ident (int ignore ATTRIBUTE_UNUSED) 1954 { 1955 static segT comment_section; 1956 segT old_section = now_seg; 1957 int old_subsection = now_subseg; 1958 1959 #ifdef md_flush_pending_output 1960 md_flush_pending_output (); 1961 #endif 1962 1963 if (!comment_section) 1964 { 1965 char *p; 1966 comment_section = subseg_new (".comment", 0); 1967 bfd_set_section_flags (stdoutput, comment_section, 1968 SEC_READONLY | SEC_HAS_CONTENTS 1969 | SEC_MERGE | SEC_STRINGS); 1970 comment_section->entsize = 1; 1971 #ifdef md_elf_section_change_hook 1972 md_elf_section_change_hook (); 1973 #endif 1974 p = frag_more (1); 1975 *p = 0; 1976 } 1977 else 1978 subseg_set (comment_section, 0); 1979 stringer (8 + 1); 1980 subseg_set (old_section, old_subsection); 1981 } 1982 1983 #ifdef INIT_STAB_SECTION 1984 1985 /* The first entry in a .stabs section is special. */ 1986 1987 void 1988 obj_elf_init_stab_section (segT seg) 1989 { 1990 char *file; 1991 char *p; 1992 char *stabstr_name; 1993 unsigned int stroff; 1994 1995 /* Force the section to align to a longword boundary. Without this, 1996 UnixWare ar crashes. */ 1997 bfd_set_section_alignment (stdoutput, seg, 2); 1998 1999 /* Make space for this first symbol. */ 2000 p = frag_more (12); 2001 /* Zero it out. */ 2002 memset (p, 0, 12); 2003 as_where (&file, NULL); 2004 stabstr_name = (char *) xmalloc (strlen (segment_name (seg)) + 4); 2005 strcpy (stabstr_name, segment_name (seg)); 2006 strcat (stabstr_name, "str"); 2007 stroff = get_stab_string_offset (file, stabstr_name); 2008 know (stroff == 1 || (stroff == 0 && file[0] == '\0')); 2009 md_number_to_chars (p, stroff, 4); 2010 seg_info (seg)->stabu.p = p; 2011 } 2012 2013 #endif 2014 2015 /* Fill in the counts in the first entry in a .stabs section. */ 2016 2017 static void 2018 adjust_stab_sections (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED) 2019 { 2020 char *name; 2021 asection *strsec; 2022 char *p; 2023 int strsz, nsyms; 2024 2025 if (strncmp (".stab", sec->name, 5)) 2026 return; 2027 if (!strcmp ("str", sec->name + strlen (sec->name) - 3)) 2028 return; 2029 2030 name = (char *) alloca (strlen (sec->name) + 4); 2031 strcpy (name, sec->name); 2032 strcat (name, "str"); 2033 strsec = bfd_get_section_by_name (abfd, name); 2034 if (strsec) 2035 strsz = bfd_section_size (abfd, strsec); 2036 else 2037 strsz = 0; 2038 nsyms = bfd_section_size (abfd, sec) / 12 - 1; 2039 2040 p = seg_info (sec)->stabu.p; 2041 gas_assert (p != 0); 2042 2043 bfd_h_put_16 (abfd, nsyms, p + 6); 2044 bfd_h_put_32 (abfd, strsz, p + 8); 2045 } 2046 2047 #ifdef NEED_ECOFF_DEBUG 2048 2049 /* This function is called by the ECOFF code. It is supposed to 2050 record the external symbol information so that the backend can 2051 write it out correctly. The ELF backend doesn't actually handle 2052 this at the moment, so we do it ourselves. We save the information 2053 in the symbol. */ 2054 2055 #ifdef OBJ_MAYBE_ELF 2056 static 2057 #endif 2058 void 2059 elf_ecoff_set_ext (symbolS *sym, struct ecoff_extr *ext) 2060 { 2061 symbol_get_bfdsym (sym)->udata.p = ext; 2062 } 2063 2064 /* This function is called by bfd_ecoff_debug_externals. It is 2065 supposed to *EXT to the external symbol information, and return 2066 whether the symbol should be used at all. */ 2067 2068 static bfd_boolean 2069 elf_get_extr (asymbol *sym, EXTR *ext) 2070 { 2071 if (sym->udata.p == NULL) 2072 return FALSE; 2073 *ext = *(EXTR *) sym->udata.p; 2074 return TRUE; 2075 } 2076 2077 /* This function is called by bfd_ecoff_debug_externals. It has 2078 nothing to do for ELF. */ 2079 2080 static void 2081 elf_set_index (asymbol *sym ATTRIBUTE_UNUSED, 2082 bfd_size_type indx ATTRIBUTE_UNUSED) 2083 { 2084 } 2085 2086 #endif /* NEED_ECOFF_DEBUG */ 2087 2088 void 2089 elf_frob_symbol (symbolS *symp, int *puntp) 2090 { 2091 struct elf_obj_sy *sy_obj; 2092 expressionS *size; 2093 2094 #ifdef NEED_ECOFF_DEBUG 2095 if (ECOFF_DEBUGGING) 2096 ecoff_frob_symbol (symp); 2097 #endif 2098 2099 sy_obj = symbol_get_obj (symp); 2100 2101 size = sy_obj->size; 2102 if (size != NULL) 2103 { 2104 if (resolve_expression (size) 2105 && size->X_op == O_constant) 2106 S_SET_SIZE (symp, size->X_add_number); 2107 else 2108 { 2109 if (flag_size_check == size_check_error) 2110 as_bad (_(".size expression for %s " 2111 "does not evaluate to a constant"), S_GET_NAME (symp)); 2112 else 2113 as_warn (_(".size expression for %s " 2114 "does not evaluate to a constant"), S_GET_NAME (symp)); 2115 } 2116 free (sy_obj->size); 2117 sy_obj->size = NULL; 2118 } 2119 2120 if (sy_obj->versioned_name != NULL) 2121 { 2122 char *p; 2123 2124 p = strchr (sy_obj->versioned_name, ELF_VER_CHR); 2125 if (p == NULL) 2126 /* We will have already reported an error about a missing version. */ 2127 *puntp = TRUE; 2128 2129 /* This symbol was given a new name with the .symver directive. 2130 2131 If this is an external reference, just rename the symbol to 2132 include the version string. This will make the relocs be 2133 against the correct versioned symbol. 2134 2135 If this is a definition, add an alias. FIXME: Using an alias 2136 will permit the debugging information to refer to the right 2137 symbol. However, it's not clear whether it is the best 2138 approach. */ 2139 2140 else if (! S_IS_DEFINED (symp)) 2141 { 2142 /* Verify that the name isn't using the @@ syntax--this is 2143 reserved for definitions of the default version to link 2144 against. */ 2145 if (p[1] == ELF_VER_CHR) 2146 { 2147 as_bad (_("invalid attempt to declare external version name" 2148 " as default in symbol `%s'"), 2149 sy_obj->versioned_name); 2150 *puntp = TRUE; 2151 } 2152 S_SET_NAME (symp, sy_obj->versioned_name); 2153 } 2154 else 2155 { 2156 if (p[1] == ELF_VER_CHR && p[2] == ELF_VER_CHR) 2157 { 2158 size_t l; 2159 2160 /* The @@@ syntax is a special case. It renames the 2161 symbol name to versioned_name with one `@' removed. */ 2162 l = strlen (&p[3]) + 1; 2163 memmove (&p[2], &p[3], l); 2164 S_SET_NAME (symp, sy_obj->versioned_name); 2165 } 2166 else 2167 { 2168 symbolS *symp2; 2169 2170 /* FIXME: Creating a new symbol here is risky. We're 2171 in the final loop over the symbol table. We can 2172 get away with it only because the symbol goes to 2173 the end of the list, where the loop will still see 2174 it. It would probably be better to do this in 2175 obj_frob_file_before_adjust. */ 2176 2177 symp2 = symbol_find_or_make (sy_obj->versioned_name); 2178 2179 /* Now we act as though we saw symp2 = sym. */ 2180 2181 S_SET_SEGMENT (symp2, S_GET_SEGMENT (symp)); 2182 2183 /* Subtracting out the frag address here is a hack 2184 because we are in the middle of the final loop. */ 2185 S_SET_VALUE (symp2, 2186 (S_GET_VALUE (symp) 2187 - symbol_get_frag (symp)->fr_address)); 2188 2189 symbol_set_frag (symp2, symbol_get_frag (symp)); 2190 2191 /* This will copy over the size information. */ 2192 copy_symbol_attributes (symp2, symp); 2193 2194 S_SET_OTHER (symp2, S_GET_OTHER (symp)); 2195 2196 if (S_IS_WEAK (symp)) 2197 S_SET_WEAK (symp2); 2198 2199 if (S_IS_EXTERNAL (symp)) 2200 S_SET_EXTERNAL (symp2); 2201 } 2202 } 2203 } 2204 2205 /* Double check weak symbols. */ 2206 if (S_IS_WEAK (symp)) 2207 { 2208 if (S_IS_COMMON (symp)) 2209 as_bad (_("symbol `%s' can not be both weak and common"), 2210 S_GET_NAME (symp)); 2211 } 2212 2213 #ifdef TC_MIPS 2214 /* The Irix 5 and 6 assemblers set the type of any common symbol and 2215 any undefined non-function symbol to STT_OBJECT. We try to be 2216 compatible, since newer Irix 5 and 6 linkers care. However, we 2217 only set undefined symbols to be STT_OBJECT if we are on Irix, 2218 because that is the only time gcc will generate the necessary 2219 .global directives to mark functions. */ 2220 2221 if (S_IS_COMMON (symp)) 2222 symbol_get_bfdsym (symp)->flags |= BSF_OBJECT; 2223 2224 if (strstr (TARGET_OS, "irix") != NULL 2225 && ! S_IS_DEFINED (symp) 2226 && (symbol_get_bfdsym (symp)->flags & BSF_FUNCTION) == 0) 2227 symbol_get_bfdsym (symp)->flags |= BSF_OBJECT; 2228 #endif 2229 } 2230 2231 struct group_list 2232 { 2233 asection **head; /* Section lists. */ 2234 unsigned int *elt_count; /* Number of sections in each list. */ 2235 unsigned int num_group; /* Number of lists. */ 2236 struct hash_control *indexes; /* Maps group name to index in head array. */ 2237 }; 2238 2239 /* Called via bfd_map_over_sections. If SEC is a member of a group, 2240 add it to a list of sections belonging to the group. INF is a 2241 pointer to a struct group_list, which is where we store the head of 2242 each list. */ 2243 2244 static void 2245 build_group_lists (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *inf) 2246 { 2247 struct group_list *list = (struct group_list *) inf; 2248 const char *group_name = elf_group_name (sec); 2249 unsigned int i; 2250 unsigned int *elem_idx; 2251 unsigned int *idx_ptr; 2252 2253 if (group_name == NULL) 2254 return; 2255 2256 /* If this group already has a list, add the section to the head of 2257 the list. */ 2258 elem_idx = (unsigned int *) hash_find (list->indexes, group_name); 2259 if (elem_idx != NULL) 2260 { 2261 elf_next_in_group (sec) = list->head[*elem_idx]; 2262 list->head[*elem_idx] = sec; 2263 list->elt_count[*elem_idx] += 1; 2264 return; 2265 } 2266 2267 /* New group. Make the arrays bigger in chunks to minimize calls to 2268 realloc. */ 2269 i = list->num_group; 2270 if ((i & 127) == 0) 2271 { 2272 unsigned int newsize = i + 128; 2273 list->head = (asection **) xrealloc (list->head, 2274 newsize * sizeof (*list->head)); 2275 list->elt_count = (unsigned int *) 2276 xrealloc (list->elt_count, newsize * sizeof (*list->elt_count)); 2277 } 2278 list->head[i] = sec; 2279 list->elt_count[i] = 1; 2280 list->num_group += 1; 2281 2282 /* Add index to hash. */ 2283 idx_ptr = (unsigned int *) xmalloc (sizeof (unsigned int)); 2284 *idx_ptr = i; 2285 hash_insert (list->indexes, group_name, idx_ptr); 2286 } 2287 2288 static void free_section_idx (const char *key ATTRIBUTE_UNUSED, void *val) 2289 { 2290 free ((unsigned int *) val); 2291 } 2292 2293 void 2294 elf_adjust_symtab (void) 2295 { 2296 struct group_list list; 2297 unsigned int i; 2298 2299 /* Go find section groups. */ 2300 list.num_group = 0; 2301 list.head = NULL; 2302 list.elt_count = NULL; 2303 list.indexes = hash_new (); 2304 bfd_map_over_sections (stdoutput, build_group_lists, &list); 2305 2306 /* Make the SHT_GROUP sections that describe each section group. We 2307 can't set up the section contents here yet, because elf section 2308 indices have yet to be calculated. elf.c:set_group_contents does 2309 the rest of the work. */ 2310 for (i = 0; i < list.num_group; i++) 2311 { 2312 const char *group_name = elf_group_name (list.head[i]); 2313 const char *sec_name; 2314 asection *s; 2315 flagword flags; 2316 struct symbol *sy; 2317 bfd_size_type size; 2318 2319 flags = SEC_READONLY | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_GROUP; 2320 for (s = list.head[i]; s != NULL; s = elf_next_in_group (s)) 2321 if ((s->flags ^ flags) & SEC_LINK_ONCE) 2322 { 2323 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD; 2324 if (s != list.head[i]) 2325 { 2326 as_warn (_("assuming all members of group `%s' are COMDAT"), 2327 group_name); 2328 break; 2329 } 2330 } 2331 2332 sec_name = ".group"; 2333 s = subseg_force_new (sec_name, 0); 2334 if (s == NULL 2335 || !bfd_set_section_flags (stdoutput, s, flags) 2336 || !bfd_set_section_alignment (stdoutput, s, 2)) 2337 { 2338 as_fatal (_("can't create group: %s"), 2339 bfd_errmsg (bfd_get_error ())); 2340 } 2341 elf_section_type (s) = SHT_GROUP; 2342 2343 /* Pass a pointer to the first section in this group. */ 2344 elf_next_in_group (s) = list.head[i]; 2345 /* Make sure that the signature symbol for the group has the 2346 name of the group. */ 2347 sy = symbol_find_exact (group_name); 2348 if (!sy 2349 || (sy != symbol_lastP 2350 && (sy->sy_next == NULL 2351 || sy->sy_next->sy_previous != sy))) 2352 { 2353 /* Create the symbol now. */ 2354 sy = symbol_new (group_name, now_seg, (valueT) 0, frag_now); 2355 #ifdef TE_SOLARIS 2356 /* Before Solaris 11 build 154, Sun ld rejects local group 2357 signature symbols, so make them weak hidden instead. */ 2358 symbol_get_bfdsym (sy)->flags |= BSF_WEAK; 2359 S_SET_OTHER (sy, STV_HIDDEN); 2360 #else 2361 symbol_get_obj (sy)->local = 1; 2362 #endif 2363 symbol_table_insert (sy); 2364 } 2365 elf_group_id (s) = symbol_get_bfdsym (sy); 2366 2367 size = 4 * (list.elt_count[i] + 1); 2368 bfd_set_section_size (stdoutput, s, size); 2369 s->contents = (unsigned char *) frag_more (size); 2370 frag_now->fr_fix = frag_now_fix_octets (); 2371 frag_wane (frag_now); 2372 } 2373 2374 /* Cleanup hash. */ 2375 hash_traverse (list.indexes, free_section_idx); 2376 hash_die (list.indexes); 2377 } 2378 2379 void 2380 elf_frob_file (void) 2381 { 2382 bfd_map_over_sections (stdoutput, adjust_stab_sections, NULL); 2383 2384 #ifdef elf_tc_final_processing 2385 elf_tc_final_processing (); 2386 #endif 2387 } 2388 2389 /* It removes any unneeded versioned symbols from the symbol table. */ 2390 2391 void 2392 elf_frob_file_before_adjust (void) 2393 { 2394 if (symbol_rootP) 2395 { 2396 symbolS *symp; 2397 2398 for (symp = symbol_rootP; symp; symp = symbol_next (symp)) 2399 if (!S_IS_DEFINED (symp)) 2400 { 2401 if (symbol_get_obj (symp)->versioned_name) 2402 { 2403 char *p; 2404 2405 /* The @@@ syntax is a special case. If the symbol is 2406 not defined, 2 `@'s will be removed from the 2407 versioned_name. */ 2408 2409 p = strchr (symbol_get_obj (symp)->versioned_name, 2410 ELF_VER_CHR); 2411 if (p != NULL && p[1] == ELF_VER_CHR && p[2] == ELF_VER_CHR) 2412 { 2413 size_t l = strlen (&p[3]) + 1; 2414 memmove (&p[1], &p[3], l); 2415 } 2416 if (symbol_used_p (symp) == 0 2417 && symbol_used_in_reloc_p (symp) == 0) 2418 symbol_remove (symp, &symbol_rootP, &symbol_lastP); 2419 } 2420 2421 /* If there was .weak foo, but foo was neither defined nor 2422 used anywhere, remove it. */ 2423 2424 else if (S_IS_WEAK (symp) 2425 && symbol_used_p (symp) == 0 2426 && symbol_used_in_reloc_p (symp) == 0) 2427 symbol_remove (symp, &symbol_rootP, &symbol_lastP); 2428 } 2429 } 2430 } 2431 2432 /* It is required that we let write_relocs have the opportunity to 2433 optimize away fixups before output has begun, since it is possible 2434 to eliminate all fixups for a section and thus we never should 2435 have generated the relocation section. */ 2436 2437 void 2438 elf_frob_file_after_relocs (void) 2439 { 2440 #ifdef NEED_ECOFF_DEBUG 2441 if (ECOFF_DEBUGGING) 2442 /* Generate the ECOFF debugging information. */ 2443 { 2444 const struct ecoff_debug_swap *debug_swap; 2445 struct ecoff_debug_info debug; 2446 char *buf; 2447 asection *sec; 2448 2449 debug_swap 2450 = get_elf_backend_data (stdoutput)->elf_backend_ecoff_debug_swap; 2451 know (debug_swap != NULL); 2452 ecoff_build_debug (&debug.symbolic_header, &buf, debug_swap); 2453 2454 /* Set up the pointers in debug. */ 2455 #define SET(ptr, offset, type) \ 2456 debug.ptr = (type) (buf + debug.symbolic_header.offset) 2457 2458 SET (line, cbLineOffset, unsigned char *); 2459 SET (external_dnr, cbDnOffset, void *); 2460 SET (external_pdr, cbPdOffset, void *); 2461 SET (external_sym, cbSymOffset, void *); 2462 SET (external_opt, cbOptOffset, void *); 2463 SET (external_aux, cbAuxOffset, union aux_ext *); 2464 SET (ss, cbSsOffset, char *); 2465 SET (external_fdr, cbFdOffset, void *); 2466 SET (external_rfd, cbRfdOffset, void *); 2467 /* ssext and external_ext are set up just below. */ 2468 2469 #undef SET 2470 2471 /* Set up the external symbols. */ 2472 debug.ssext = debug.ssext_end = NULL; 2473 debug.external_ext = debug.external_ext_end = NULL; 2474 if (! bfd_ecoff_debug_externals (stdoutput, &debug, debug_swap, TRUE, 2475 elf_get_extr, elf_set_index)) 2476 as_fatal (_("failed to set up debugging information: %s"), 2477 bfd_errmsg (bfd_get_error ())); 2478 2479 sec = bfd_get_section_by_name (stdoutput, ".mdebug"); 2480 gas_assert (sec != NULL); 2481 2482 know (!stdoutput->output_has_begun); 2483 2484 /* We set the size of the section, call bfd_set_section_contents 2485 to force the ELF backend to allocate a file position, and then 2486 write out the data. FIXME: Is this really the best way to do 2487 this? */ 2488 bfd_set_section_size 2489 (stdoutput, sec, bfd_ecoff_debug_size (stdoutput, &debug, debug_swap)); 2490 2491 /* Pass BUF to bfd_set_section_contents because this will 2492 eventually become a call to fwrite, and ISO C prohibits 2493 passing a NULL pointer to a stdio function even if the 2494 pointer will not be used. */ 2495 if (! bfd_set_section_contents (stdoutput, sec, buf, 0, 0)) 2496 as_fatal (_("can't start writing .mdebug section: %s"), 2497 bfd_errmsg (bfd_get_error ())); 2498 2499 know (stdoutput->output_has_begun); 2500 know (sec->filepos != 0); 2501 2502 if (! bfd_ecoff_write_debug (stdoutput, &debug, debug_swap, 2503 sec->filepos)) 2504 as_fatal (_("could not write .mdebug section: %s"), 2505 bfd_errmsg (bfd_get_error ())); 2506 } 2507 #endif /* NEED_ECOFF_DEBUG */ 2508 } 2509 2510 #ifdef SCO_ELF 2511 2512 /* Heavily plagiarized from obj_elf_version. The idea is to emit the 2513 SCO specific identifier in the .notes section to satisfy the SCO 2514 linker. 2515 2516 This looks more complicated than it really is. As opposed to the 2517 "obvious" solution, this should handle the cross dev cases 2518 correctly. (i.e, hosting on a 64 bit big endian processor, but 2519 generating SCO Elf code) Efficiency isn't a concern, as there 2520 should be exactly one of these sections per object module. 2521 2522 SCO OpenServer 5 identifies it's ELF modules with a standard ELF 2523 .note section. 2524 2525 int_32 namesz = 4 ; Name size 2526 int_32 descsz = 12 ; Descriptive information 2527 int_32 type = 1 ; 2528 char name[4] = "SCO" ; Originator name ALWAYS SCO + NULL 2529 int_32 version = (major ver # << 16) | version of tools ; 2530 int_32 source = (tool_id << 16 ) | 1 ; 2531 int_32 info = 0 ; These are set by the SCO tools, but we 2532 don't know enough about the source 2533 environment to set them. SCO ld currently 2534 ignores them, and recommends we set them 2535 to zero. */ 2536 2537 #define SCO_MAJOR_VERSION 0x1 2538 #define SCO_MINOR_VERSION 0x1 2539 2540 void 2541 sco_id (void) 2542 { 2543 2544 char *name; 2545 unsigned int c; 2546 char ch; 2547 char *p; 2548 asection *seg = now_seg; 2549 subsegT subseg = now_subseg; 2550 Elf_Internal_Note i_note; 2551 Elf_External_Note e_note; 2552 asection *note_secp = NULL; 2553 int i, len; 2554 2555 /* create the .note section */ 2556 2557 note_secp = subseg_new (".note", 0); 2558 bfd_set_section_flags (stdoutput, 2559 note_secp, 2560 SEC_HAS_CONTENTS | SEC_READONLY); 2561 2562 /* process the version string */ 2563 2564 i_note.namesz = 4; 2565 i_note.descsz = 12; /* 12 descriptive bytes */ 2566 i_note.type = NT_VERSION; /* Contains a version string */ 2567 2568 p = frag_more (sizeof (i_note.namesz)); 2569 md_number_to_chars (p, i_note.namesz, 4); 2570 2571 p = frag_more (sizeof (i_note.descsz)); 2572 md_number_to_chars (p, i_note.descsz, 4); 2573 2574 p = frag_more (sizeof (i_note.type)); 2575 md_number_to_chars (p, i_note.type, 4); 2576 2577 p = frag_more (4); 2578 strcpy (p, "SCO"); 2579 2580 /* Note: this is the version number of the ELF we're representing */ 2581 p = frag_more (4); 2582 md_number_to_chars (p, (SCO_MAJOR_VERSION << 16) | (SCO_MINOR_VERSION), 4); 2583 2584 /* Here, we pick a magic number for ourselves (yes, I "registered" 2585 it with SCO. The bottom bit shows that we are compat with the 2586 SCO ABI. */ 2587 p = frag_more (4); 2588 md_number_to_chars (p, 0x4c520000 | 0x0001, 4); 2589 2590 /* If we knew (or cared) what the source language options were, we'd 2591 fill them in here. SCO has given us permission to ignore these 2592 and just set them to zero. */ 2593 p = frag_more (4); 2594 md_number_to_chars (p, 0x0000, 4); 2595 2596 frag_align (2, 0, 0); 2597 2598 /* We probably can't restore the current segment, for there likely 2599 isn't one yet... */ 2600 if (seg && subseg) 2601 subseg_set (seg, subseg); 2602 2603 } 2604 2605 #endif /* SCO_ELF */ 2606 2607 static void 2608 elf_generate_asm_lineno (void) 2609 { 2610 #ifdef NEED_ECOFF_DEBUG 2611 if (ECOFF_DEBUGGING) 2612 ecoff_generate_asm_lineno (); 2613 #endif 2614 } 2615 2616 static void 2617 elf_process_stab (segT sec ATTRIBUTE_UNUSED, 2618 int what ATTRIBUTE_UNUSED, 2619 const char *string ATTRIBUTE_UNUSED, 2620 int type ATTRIBUTE_UNUSED, 2621 int other ATTRIBUTE_UNUSED, 2622 int desc ATTRIBUTE_UNUSED) 2623 { 2624 #ifdef NEED_ECOFF_DEBUG 2625 if (ECOFF_DEBUGGING) 2626 ecoff_stab (sec, what, string, type, other, desc); 2627 #endif 2628 } 2629 2630 static int 2631 elf_separate_stab_sections (void) 2632 { 2633 #ifdef NEED_ECOFF_DEBUG 2634 return (!ECOFF_DEBUGGING); 2635 #else 2636 return 1; 2637 #endif 2638 } 2639 2640 static void 2641 elf_init_stab_section (segT seg) 2642 { 2643 #ifdef NEED_ECOFF_DEBUG 2644 if (!ECOFF_DEBUGGING) 2645 #endif 2646 obj_elf_init_stab_section (seg); 2647 } 2648 2649 const struct format_ops elf_format_ops = 2650 { 2651 bfd_target_elf_flavour, 2652 0, /* dfl_leading_underscore */ 2653 1, /* emit_section_symbols */ 2654 elf_begin, 2655 elf_file_symbol, 2656 elf_frob_symbol, 2657 elf_frob_file, 2658 elf_frob_file_before_adjust, 2659 0, /* obj_frob_file_before_fix */ 2660 elf_frob_file_after_relocs, 2661 elf_s_get_size, elf_s_set_size, 2662 elf_s_get_align, elf_s_set_align, 2663 elf_s_get_other, 2664 elf_s_set_other, 2665 0, /* s_get_desc */ 2666 0, /* s_set_desc */ 2667 0, /* s_get_type */ 2668 0, /* s_set_type */ 2669 elf_copy_symbol_attributes, 2670 elf_generate_asm_lineno, 2671 elf_process_stab, 2672 elf_separate_stab_sections, 2673 elf_init_stab_section, 2674 elf_sec_sym_ok_for_reloc, 2675 elf_pop_insert, 2676 #ifdef NEED_ECOFF_DEBUG 2677 elf_ecoff_set_ext, 2678 #else 2679 0, /* ecoff_set_ext */ 2680 #endif 2681 elf_obj_read_begin_hook, 2682 elf_obj_symbol_new_hook, 2683 0, 2684 elf_adjust_symtab 2685 }; 2686
