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