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