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