X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=bfd%2Felf32-sparc.c;h=f02702c919e3ec6371b30d6f973569724501e774;hb=60dac29966ebf4a075b7d70257f008c53756e3fb;hp=7cc0048aded0634cbd2db34b6077171603323f39;hpb=ff12f303355b20de1260bc1d007f973bd02615dc;p=deliverable%2Fbinutils-gdb.git diff --git a/bfd/elf32-sparc.c b/bfd/elf32-sparc.c index 7cc0048ade..f02702c919 100644 --- a/bfd/elf32-sparc.c +++ b/bfd/elf32-sparc.c @@ -1,5 +1,5 @@ /* SPARC-specific support for 32-bit ELF - Copyright (C) 1993, 1994, 1995, 1996 Free Software Foundation, Inc. + Copyright (C) 1993, 94, 95, 96, 97, 98, 1999 Free Software Foundation, Inc. This file is part of BFD, the Binary File Descriptor library. @@ -51,13 +51,7 @@ static boolean elf32_sparc_object_p static void elf32_sparc_final_write_processing PARAMS ((bfd *, boolean)); -/* The howto table and associated functions. - ??? elf64-sparc.c has its own copy for the moment to ease transition - since some of the relocation values have changed. At some point we'll - want elf64-sparc.c to switch over and use this table. - ??? Do we want to recognize (or flag as errors) some of the 64 bit entries - if the target is elf32-sparc. -*/ +/* The relocation "howto" table. */ static bfd_reloc_status_type sparc_elf_notsupported_reloc PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); @@ -98,42 +92,44 @@ reloc_howto_type _bfd_sparc_elf_howto_table[] = HOWTO(R_SPARC_PCPLT10, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_PCPLT10", false,0,0x00000000,true), HOWTO(R_SPARC_10, 0,2,10,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_10", false,0,0x000003ff,true), HOWTO(R_SPARC_11, 0,2,11,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_11", false,0,0x000007ff,true), - /* ??? If we need to handle R_SPARC_64 then we need (figuratively) - --enable-64-bit-bfd. That causes objdump to print address as 64 bits - which we really don't want on an elf32-sparc system. There may be other - consequences which we may not want (at least not until it's proven they're - necessary) so for now these are only enabled ifdef BFD64. */ -#ifdef BFD64 - HOWTO(R_SPARC_64, 0,4,00,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_64", false,0,~ (bfd_vma) 0, true), - /* ??? These don't make sense except in 64 bit systems so they're disabled - ifndef BFD64 too (for now). */ - HOWTO(R_SPARC_OLO10, 0,2,10,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_OLO10", false,0,0x000003ff,true), - HOWTO(R_SPARC_HH22, 42,2,22,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HH22", false,0,0x003fffff,true), - HOWTO(R_SPARC_HM10, 32,2,10,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HM10", false,0,0x000003ff,true), - HOWTO(R_SPARC_LM22, 10,2,22,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LM22", false,0,0x003fffff,true), - HOWTO(R_SPARC_PC_HH22, 42,2,22,true, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HH22", false,0,0x003fffff,true), - HOWTO(R_SPARC_PC_HM10, 32,2,10,true, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_HM10", false,0,0x000003ff,true), - HOWTO(R_SPARC_PC_LM22, 10,2,22,true, 0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_LM22", false,0,0x003fffff,true), -#else - HOWTO(R_SPARC_64, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_64", false,0,0x00000000,true), - HOWTO(R_SPARC_OLO10, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_OLO10", false,0,0x00000000,true), + /* These are for sparc64 in a 64 bit environment. + Values need to be here because the table is indexed by reloc number. */ + HOWTO(R_SPARC_64, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_64", false,0,0x00000000,true), + HOWTO(R_SPARC_OLO10, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_OLO10", false,0,0x00000000,true), HOWTO(R_SPARC_HH22, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_HH22", false,0,0x00000000,true), HOWTO(R_SPARC_HM10, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_HM10", false,0,0x00000000,true), HOWTO(R_SPARC_LM22, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_LM22", false,0,0x00000000,true), - HOWTO(R_SPARC_PC_HH22, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_PC_HH22", false,0,0x00000000,true), - HOWTO(R_SPARC_PC_HM10, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_PC_HM10", false,0,0x00000000,true), - HOWTO(R_SPARC_PC_LM22, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_PC_LM22", false,0,0x00000000,true), -#endif + HOWTO(R_SPARC_PC_HH22, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_PC_HH22", false,0,0x00000000,true), + HOWTO(R_SPARC_PC_HM10, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_PC_HM10", false,0,0x00000000,true), + HOWTO(R_SPARC_PC_LM22, 0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc, "R_SPARC_PC_LM22", false,0,0x00000000,true), + /* End sparc64 in 64 bit environment values. + The following are for sparc64 in a 32 bit environment. */ HOWTO(R_SPARC_WDISP16, 2,2,16,true, 0,complain_overflow_signed, sparc_elf_wdisp16_reloc,"R_SPARC_WDISP16", false,0,0x00000000,true), - HOWTO(R_SPARC_WDISP19, 2,2,22,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP19", false,0,0x0007ffff,true), - HOWTO(R_SPARC_GLOB_JMP, 0,0,00,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_GLOB_JMP",false,0,0x00000000,true), + HOWTO(R_SPARC_WDISP19, 2,2,19,true, 0,complain_overflow_signed, bfd_elf_generic_reloc, "R_SPARC_WDISP19", false,0,0x0007ffff,true), + HOWTO(R_SPARC_UNUSED_42, 0,0, 0,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_UNUSED_42",false,0,0x00000000,true), HOWTO(R_SPARC_7, 0,2, 7,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_7", false,0,0x0000007f,true), HOWTO(R_SPARC_5, 0,2, 5,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_5", false,0,0x0000001f,true), HOWTO(R_SPARC_6, 0,2, 6,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_6", false,0,0x0000003f,true), + HOWTO(R_SPARC_NONE, 0,0, 0,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", false,0,0x00000000,true), + HOWTO(R_SPARC_NONE, 0,0, 0,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", false,0,0x00000000,true), + HOWTO(R_SPARC_NONE, 0,0, 0,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", false,0,0x00000000,true), + HOWTO(R_SPARC_NONE, 0,0, 0,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", false,0,0x00000000,true), + HOWTO(R_SPARC_NONE, 0,0, 0,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", false,0,0x00000000,true), + HOWTO(R_SPARC_NONE, 0,0, 0,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", false,0,0x00000000,true), + HOWTO(R_SPARC_NONE, 0,0, 0,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", false,0,0x00000000,true), + HOWTO(R_SPARC_NONE, 0,0, 0,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", false,0,0x00000000,true), + HOWTO(R_SPARC_NONE, 0,0, 0,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", false,0,0x00000000,true), + HOWTO(R_SPARC_NONE, 0,0, 0,false,0,complain_overflow_dont, bfd_elf_generic_reloc, "R_SPARC_NONE", false,0,0x00000000,true), + HOWTO(R_SPARC_REV32, 0,2,32,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc, "R_SPARC_REV32", false,0,0xffffffff,true), }; +static reloc_howto_type elf32_sparc_vtinherit_howto = + HOWTO (R_SPARC_GNU_VTINHERIT, 0,2,0,false,0,complain_overflow_dont, NULL, "R_SPARC_GNU_VTINHERIT", false,0, 0, false); +static reloc_howto_type elf32_sparc_vtentry_howto = + HOWTO (R_SPARC_GNU_VTENTRY, 0,2,0,false,0,complain_overflow_dont, _bfd_elf_rel_vtable_reloc_fn,"R_SPARC_GNU_VTENTRY", false,0,0, false); + struct elf_reloc_map { - unsigned char bfd_reloc_val; + bfd_reloc_code_real_type bfd_reloc_val; unsigned char elf_reloc_val; }; @@ -143,9 +139,7 @@ static CONST struct elf_reloc_map sparc_reloc_map[] = { BFD_RELOC_16, R_SPARC_16, }, { BFD_RELOC_8, R_SPARC_8 }, { BFD_RELOC_8_PCREL, R_SPARC_DISP8 }, - /* ??? This might cause us to need separate functions in elf{32,64}-sparc.c - (we could still have just one table), but is this reloc ever used? */ - { BFD_RELOC_CTOR, R_SPARC_32 }, /* @@ Assumes 32 bits. */ + { BFD_RELOC_CTOR, R_SPARC_32 }, { BFD_RELOC_32, R_SPARC_32 }, { BFD_RELOC_32_PCREL, R_SPARC_DISP32 }, { BFD_RELOC_HI22, R_SPARC_HI22 }, @@ -178,10 +172,12 @@ static CONST struct elf_reloc_map sparc_reloc_map[] = {BFD_RELOC_SPARC_PC_LM22, R_SPARC_PC_LM22}, {BFD_RELOC_SPARC_WDISP16, R_SPARC_WDISP16}, {BFD_RELOC_SPARC_WDISP19, R_SPARC_WDISP19}, - {BFD_RELOC_SPARC_GLOB_JMP, R_SPARC_GLOB_JMP}, {BFD_RELOC_SPARC_7, R_SPARC_7}, {BFD_RELOC_SPARC_5, R_SPARC_5}, {BFD_RELOC_SPARC_6, R_SPARC_6}, + {BFD_RELOC_SPARC_REV32, R_SPARC_REV32 }, + {BFD_RELOC_VTABLE_INHERIT, R_SPARC_GNU_VTINHERIT}, + {BFD_RELOC_VTABLE_ENTRY, R_SPARC_GNU_VTENTRY}, }; static reloc_howto_type * @@ -190,12 +186,24 @@ elf32_sparc_reloc_type_lookup (abfd, code) bfd_reloc_code_real_type code; { unsigned int i; - for (i = 0; i < sizeof (sparc_reloc_map) / sizeof (struct elf_reloc_map); i++) + + switch (code) { - if (sparc_reloc_map[i].bfd_reloc_val == code) - return &_bfd_sparc_elf_howto_table[(int) sparc_reloc_map[i].elf_reloc_val]; + case BFD_RELOC_VTABLE_INHERIT: + return &elf32_sparc_vtinherit_howto; + + case BFD_RELOC_VTABLE_ENTRY: + return &elf32_sparc_vtentry_howto; + + default: + for (i = 0; i < sizeof (sparc_reloc_map) / sizeof (struct elf_reloc_map); i++) + { + if (sparc_reloc_map[i].bfd_reloc_val == code) + return &_bfd_sparc_elf_howto_table[(int) sparc_reloc_map[i].elf_reloc_val]; + } } - return 0; + bfd_set_error (bfd_error_bad_value); + return NULL; } /* We need to use ELF32_R_TYPE so we have our own copy of this function, @@ -207,8 +215,20 @@ elf32_sparc_info_to_howto (abfd, cache_ptr, dst) arelent *cache_ptr; Elf_Internal_Rela *dst; { - BFD_ASSERT (ELF32_R_TYPE(dst->r_info) < (unsigned int) R_SPARC_max); - cache_ptr->howto = &_bfd_sparc_elf_howto_table[ELF32_R_TYPE(dst->r_info)]; + switch (ELF32_R_TYPE(dst->r_info)) + { + case R_SPARC_GNU_VTINHERIT: + cache_ptr->howto = &elf32_sparc_vtinherit_howto; + break; + + case R_SPARC_GNU_VTENTRY: + cache_ptr->howto = &elf32_sparc_vtentry_howto; + break; + + default: + BFD_ASSERT (ELF32_R_TYPE(dst->r_info) < (unsigned int) R_SPARC_max_std); + cache_ptr->howto = &_bfd_sparc_elf_howto_table[ELF32_R_TYPE(dst->r_info)]; + } } /* For unsupported relocs. */ @@ -276,10 +296,10 @@ sparc_elf_wdisp16_reloc (abfd, + input_section->output_offset); relocation -= reloc_entry->address; - x = bfd_get_32 (abfd, (char *) data + reloc_entry->address); + x = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address); x |= ((((relocation >> 2) & 0xc000) << 6) | ((relocation >> 2) & 0x3fff)); - bfd_put_32 (abfd, x, (char *) data + reloc_entry->address); + bfd_put_32 (abfd, x, (bfd_byte *) data + reloc_entry->address); if ((bfd_signed_vma) relocation < - 0x40000 || (bfd_signed_vma) relocation > 0x3ffff) @@ -403,12 +423,12 @@ elf32_sparc_check_relocs (abfd, info, sec, relocs) if (h != NULL) { - if (h->got_offset != (bfd_vma) -1) + if (h->got.offset != (bfd_vma) -1) { /* We have already allocated space in the .got. */ break; } - h->got_offset = sgot->_raw_size; + h->got.offset = sgot->_raw_size; /* Make sure this symbol is output as a dynamic symbol. */ if (h->dynindx == -1) @@ -472,10 +492,11 @@ elf32_sparc_check_relocs (abfd, info, sec, relocs) if (h == NULL) { - /* It does not make sense to have a procedure linkage - table entry for a local symbol. */ - bfd_set_error (bfd_error_bad_value); - return false; + /* The Solaris native assembler will generate a WPLT30 + reloc for a local symbol if you assemble a call from + one section to another when using -K pic. We treat + it as WDISP30. */ + break; } /* Make sure this symbol is output as a dynamic symbol. */ @@ -502,7 +523,18 @@ elf32_sparc_check_relocs (abfd, info, sec, relocs) case R_SPARC_WDISP22: case R_SPARC_WDISP19: case R_SPARC_WDISP16: - if (h == NULL) + /* If we are linking with -Bsymbolic, we do not need to copy + a PC relative reloc against a global symbol which is + defined in an object we are including in the link (i.e., + DEF_REGULAR is set). FIXME: At this point we have not + seen all the input files, so it is possible that + DEF_REGULAR is not set now but will be set later (it is + never cleared). This needs to be handled as in + elf32-i386.c. */ + if (h == NULL + || (info->symbolic + && (h->elf_link_hash_flags + & ELF_LINK_HASH_DEF_REGULAR) != 0)) break; /* Fall through. */ case R_SPARC_8: @@ -555,6 +587,16 @@ elf32_sparc_check_relocs (abfd, info, sec, relocs) break; + case R_SPARC_GNU_VTINHERIT: + if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) + return false; + break; + + case R_SPARC_GNU_VTENTRY: + if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend)) + return false; + break; + default: break; } @@ -563,6 +605,111 @@ elf32_sparc_check_relocs (abfd, info, sec, relocs) return true; } +static asection * +elf32_sparc_gc_mark_hook (abfd, info, rel, h, sym) + bfd *abfd; + struct bfd_link_info *info; + Elf_Internal_Rela *rel; + struct elf_link_hash_entry *h; + Elf_Internal_Sym *sym; +{ + + if (h != NULL) + { + switch (ELF32_R_TYPE (rel->r_info)) + { + case R_SPARC_GNU_VTINHERIT: + case R_SPARC_GNU_VTENTRY: + break; + + default: + switch (h->root.type) + { + case bfd_link_hash_defined: + case bfd_link_hash_defweak: + return h->root.u.def.section; + + case bfd_link_hash_common: + return h->root.u.c.p->section; + } + } + } + else + { + if (!(elf_bad_symtab (abfd) + && ELF_ST_BIND (sym->st_info) != STB_LOCAL) + && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE) + && sym->st_shndx != SHN_COMMON)) + { + return bfd_section_from_elf_index (abfd, sym->st_shndx); + } + } + + return NULL; +} + +/* Update the got entry reference counts for the section being removed. */ +static boolean +elf32_sparc_gc_sweep_hook (abfd, info, sec, relocs) + bfd *abfd; + struct bfd_link_info *info; + asection *sec; + const Elf_Internal_Rela *relocs; +{ + + Elf_Internal_Shdr *symtab_hdr; + struct elf_link_hash_entry **sym_hashes; + bfd_signed_vma *local_got_refcounts; + const Elf_Internal_Rela *rel, *relend; + unsigned long r_symndx; + struct elf_link_hash_entry *h; + + symtab_hdr = &elf_tdata (abfd)->symtab_hdr; + sym_hashes = elf_sym_hashes (abfd); + local_got_refcounts = elf_local_got_refcounts (abfd); + + relend = relocs + sec->reloc_count; + for (rel = relocs; rel < relend; rel++) + switch (ELF32_R_TYPE (rel->r_info)) + { + case R_SPARC_GOT10: + case R_SPARC_GOT13: + case R_SPARC_GOT22: + r_symndx = ELF32_R_SYM (rel->r_info); + if (r_symndx >= symtab_hdr->sh_info) + { + h = sym_hashes[r_symndx - symtab_hdr->sh_info]; + if (h->got.refcount > 0) + h->got.refcount--; + } + else + { + if (local_got_refcounts[r_symndx] > 0) + local_got_refcounts[r_symndx]--; + } + break; + + case R_SPARC_PLT32: + case R_SPARC_HIPLT22: + case R_SPARC_LOPLT10: + case R_SPARC_PCPLT32: + case R_SPARC_PCPLT10: + r_symndx = ELF32_R_SYM (rel->r_info); + if (r_symndx >= symtab_hdr->sh_info) + { + h = sym_hashes[r_symndx - symtab_hdr->sh_info]; + if (h->plt.refcount > 0) + h->plt.refcount--; + } + break; + + default: + break; + } + + return true; +} + /* Adjust a symbol defined by a dynamic object and referenced by a regular object. The current definition is in some section of the dynamic object, but we're not including those sections. We have to @@ -593,18 +740,34 @@ elf32_sparc_adjust_dynamic_symbol (info, h) /* If this is a function, put it in the procedure linkage table. We will fill in the contents of the procedure linkage table later - (although we could actually do it here). */ + (although we could actually do it here). The STT_NOTYPE + condition is a hack specifically for the Oracle libraries + delivered for Solaris; for some inexplicable reason, they define + some of their functions as STT_NOTYPE when they really should be + STT_FUNC. */ if (h->type == STT_FUNC - || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0) + || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0 + || (h->type == STT_NOTYPE + && (h->root.type == bfd_link_hash_defined + || h->root.type == bfd_link_hash_defweak) + && (h->root.u.def.section->flags & SEC_CODE) != 0)) { - if (! elf_hash_table (info)->dynamic_sections_created) + if (! elf_hash_table (info)->dynamic_sections_created + || ((!info->shared || info->symbolic || h->dynindx == -1) + && (h->elf_link_hash_flags + & ELF_LINK_HASH_DEF_REGULAR) != 0)) { /* This case can occur if we saw a WPLT30 reloc in an input - file, but none of the input files were dynamic objects. - In such a case, we don't actually need to build a - procedure linkage table, and we can just do a WDISP30 - reloc instead. */ - BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0); + file, but none of the input files were dynamic objects. + Or, when linking the main application or a -Bsymbolic + shared library against PIC code. Or when a global symbol + has been made private, e.g. via versioning. + + In these cases we know what value the symbol will resolve + to, so we don't actually need to build a procedure linkage + table, and we can just do a WDISP30 reloc instead. */ + + h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT; return true; } @@ -622,19 +785,19 @@ elf32_sparc_adjust_dynamic_symbol (info, h) return false; } - /* If this symbol is not defined in a regular file, and we are - not generating a shared library, then set the symbol to this - location in the .plt. This is required to make function - pointers compare as equal between the normal executable and - the shared library. */ - if (! info->shared - && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) - { - h->root.u.def.section = s; - h->root.u.def.value = s->_raw_size; - } + /* If this symbol is not defined in a regular file, and we are + not generating a shared library, then set the symbol to this + location in the .plt. This is required to make function + pointers compare as equal between the normal executable and + the shared library. */ + if (! info->shared + && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) + { + h->root.u.def.section = s; + h->root.u.def.value = s->_raw_size; + } - h->plt_offset = s->_raw_size; + h->plt.offset = s->_raw_size; /* Make room for this entry. */ s->_raw_size += PLT_ENTRY_SIZE; @@ -683,14 +846,11 @@ elf32_sparc_adjust_dynamic_symbol (info, h) s = bfd_get_section_by_name (dynobj, ".dynbss"); BFD_ASSERT (s != NULL); - /* If the symbol is currently defined in the .bss section of the - dynamic object, then it is OK to simply initialize it to zero. - If the symbol is in some other section, we must generate a - R_SPARC_COPY reloc to tell the dynamic linker to copy the initial - value out of the dynamic object and into the runtime process - image. We need to remember the offset into the .rel.bss section - we are going to use. */ - if ((h->root.u.def.section->flags & SEC_LOAD) != 0) + /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker + to copy the initial value out of the dynamic object and into the + runtime process image. We need to remember the offset into the + .rel.bss section we are going to use. */ + if ((h->root.u.def.section->flags & SEC_ALLOC) != 0) { asection *srel; @@ -805,13 +965,17 @@ elf32_sparc_size_dynamic_sections (output_bfd, info) } else { + const char *outname; asection *target; /* If this relocation section applies to a read only section, then we probably need a DT_TEXTREL entry. */ - target = bfd_get_section_by_name (output_bfd, name + 5); + outname = bfd_get_section_name (output_bfd, + s->output_section); + target = bfd_get_section_by_name (output_bfd, outname + 5); if (target != NULL - && (target->flags & SEC_READONLY) != 0) + && (target->flags & SEC_READONLY) != 0 + && (target->flags & SEC_ALLOC) != 0) reltext = true; if (strcmp (name, ".rela.plt") == 0) @@ -831,15 +995,7 @@ elf32_sparc_size_dynamic_sections (output_bfd, info) if (strip) { - asection **spp; - - for (spp = &s->output_section->owner->sections; - *spp != s->output_section; - spp = &(*spp)->next) - ; - *spp = s->output_section->next; - --s->output_section->owner->section_count; - + _bfd_strip_section_from_output (s); continue; } @@ -862,12 +1018,10 @@ elf32_sparc_size_dynamic_sections (output_bfd, info) return false; } - if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)) - return false; - if (relplt) { - if (! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0) + if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0) + || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0) || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_RELA) || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0)) return false; @@ -887,26 +1041,33 @@ elf32_sparc_size_dynamic_sections (output_bfd, info) } /* If we are generating a shared library, we generate a section - symbol for each output section. These are local symbols, which - means that they must come first in the dynamic symbol table. - That means we must increment the dynamic symbol index of every - other dynamic symbol. */ + symbol for each output section for which we might need to copy + relocs. These are local symbols, which means that they must come + first in the dynamic symbol table. That means we must increment + the dynamic symbol index of every other dynamic symbol. */ if (info->shared) { - int c, i; + int c; - c = bfd_count_sections (output_bfd); - elf_link_hash_traverse (elf_hash_table (info), - elf32_sparc_adjust_dynindx, - (PTR) &c); - elf_hash_table (info)->dynsymcount += c; - - for (i = 1, s = output_bfd->sections; s != NULL; s = s->next, i++) + c = 0; + for (s = output_bfd->sections; s != NULL; s = s->next) { - elf_section_data (s)->dynindx = i; + if ((s->flags & SEC_LINKER_CREATED) != 0 + || (s->flags & SEC_ALLOC) == 0) + continue; + + elf_section_data (s)->dynindx = c + 1; + /* These symbols will have no names, so we don't need to fiddle with dynstr_index. */ + + ++c; } + + elf_link_hash_traverse (elf_hash_table (info), + elf32_sparc_adjust_dynindx, + (PTR) &c); + elf_hash_table (info)->dynsymcount += c; } return true; @@ -980,7 +1141,12 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section, bfd_reloc_status_type r; r_type = ELF32_R_TYPE (rel->r_info); - if (r_type < 0 || r_type >= (int) R_SPARC_max) + + if (r_type == R_SPARC_GNU_VTINHERIT + || r_type == R_SPARC_GNU_VTENTRY) + continue; + + if (r_type < 0 || r_type >= (int) R_SPARC_max_std) { bfd_set_error (bfd_error_bad_value); return false; @@ -1031,17 +1197,17 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section, { sec = h->root.u.def.section; if ((r_type == R_SPARC_WPLT30 - && h->plt_offset != (bfd_vma) -1) + && h->plt.offset != (bfd_vma) -1) || ((r_type == R_SPARC_GOT10 || r_type == R_SPARC_GOT13 || r_type == R_SPARC_GOT22) && elf_hash_table (info)->dynamic_sections_created && (! info->shared - || ! info->symbolic + || (! info->symbolic && h->dynindx != -1) || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)) || (info->shared - && (! info->symbolic + && ((! info->symbolic && h->dynindx != -1) || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) && (r_type == R_SPARC_8 @@ -1076,7 +1242,7 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section, } else if (h->root.type == bfd_link_hash_undefweak) relocation = 0; - else if (info->shared && !info->symbolic) + else if (info->shared && !info->symbolic && !info->no_undefined) relocation = 0; else { @@ -1105,20 +1271,21 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section, { bfd_vma off; - off = h->got_offset; + off = h->got.offset; BFD_ASSERT (off != (bfd_vma) -1); if (! elf_hash_table (info)->dynamic_sections_created || (info->shared - && info->symbolic + && (info->symbolic || h->dynindx == -1) && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))) { /* This is actually a static link, or it is a -Bsymbolic link and the symbol is defined - locally. We must initialize this entry in the - global offset table. Since the offset must - always be a multiple of 4, we use the least - significant bit to record whether we have + locally, or the symbol was forced to be local + because of a version file. We must initialize + this entry in the global offset table. Since the + offset must always be a multiple of 4, we use the + least significant bit to record whether we have initialized it already. When doing a dynamic link, we create a .rela.got @@ -1130,7 +1297,7 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section, { bfd_put_32 (output_bfd, relocation, sgot->contents + off); - h->got_offset |= 1; + h->got.offset |= 1; } } @@ -1187,9 +1354,15 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section, case R_SPARC_WPLT30: /* Relocation is to the entry for this symbol in the procedure linkage table. */ - BFD_ASSERT (h != NULL); - if (h->plt_offset == (bfd_vma) -1) + /* The Solaris native assembler will generate a WPLT30 reloc + for a local symbol if you assemble a call from one + section to another when using -K pic. We treat it as + WDISP30. */ + if (h == NULL) + break; + + if (h->plt.offset == (bfd_vma) -1) { /* We didn't make a PLT entry for this symbol. This happens when statically linking PIC code, or when @@ -1205,7 +1378,7 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section, relocation = (splt->output_section->vma + splt->output_offset - + h->plt_offset); + + h->plt.offset); break; case R_SPARC_PC10: @@ -1221,7 +1394,10 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section, case R_SPARC_WDISP22: case R_SPARC_WDISP19: case R_SPARC_WDISP16: - if (h == NULL) + if (h == NULL + || (info->symbolic + && (h->elf_link_hash_flags + & ELF_LINK_HASH_DEF_REGULAR) != 0)) break; /* Fall through. */ case R_SPARC_8: @@ -1235,6 +1411,7 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section, if (info->shared) { Elf_Internal_Rela outrel; + boolean skip; /* When generating a shared object, these relocations are copied into the output file to be resolved at run @@ -1260,13 +1437,35 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section, BFD_ASSERT (sreloc != NULL); } - outrel.r_offset = (rel->r_offset - + input_section->output_section->vma - + input_section->output_offset); - if (h != NULL - && (! info->symbolic - || (h->elf_link_hash_flags - & ELF_LINK_HASH_DEF_REGULAR) == 0)) + skip = false; + + if (elf_section_data (input_section)->stab_info == NULL) + outrel.r_offset = rel->r_offset; + else + { + bfd_vma off; + + off = (_bfd_stab_section_offset + (output_bfd, &elf_hash_table (info)->stab_info, + input_section, + &elf_section_data (input_section)->stab_info, + rel->r_offset)); + if (off == (bfd_vma) -1) + skip = true; + outrel.r_offset = off; + } + + outrel.r_offset += (input_section->output_section->vma + + input_section->output_offset); + + if (skip) + memset (&outrel, 0, sizeof outrel); + /* h->dynindx may be -1 if the symbol was marked to + become local. */ + else if (h != NULL + && ((! info->symbolic && h->dynindx != -1) + || (h->elf_link_hash_flags + & ELF_LINK_HASH_DEF_REGULAR) == 0)) { BFD_ASSERT (h->dynindx != -1); outrel.r_info = ELF32_R_INFO (h->dynindx, r_type); @@ -1305,12 +1504,30 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section, osec = sec->output_section; indx = elf_section_data (osec)->dynindx; + + /* FIXME: we really should be able to link non-pic + shared libraries. */ if (indx == 0) - abort (); + { + BFD_FAIL (); + (*_bfd_error_handler) + (_("%s: probably compiled without -fPIC?"), + bfd_get_filename (input_bfd)); + bfd_set_error (bfd_error_bad_value); + return false; + } } outrel.r_info = ELF32_R_INFO (indx, r_type); - outrel.r_addend = relocation + rel->r_addend; + + /* For non-RELATIVE dynamic relocations, we keep the + same symbol, and so generally the same addend. But + we do need to adjust those relocations referencing + sections. */ + outrel.r_addend = rel->r_addend; + if (r_symndx < symtab_hdr->sh_info + && ELF_ST_TYPE (sym->st_info) == STT_SECTION) + outrel.r_addend += sec->output_offset+sym->st_value; } } @@ -1321,19 +1538,20 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section, ++sreloc->reloc_count; /* This reloc will be computed at runtime, so there's no - need to do anything now. */ - continue; + need to do anything now, unless this is a RELATIVE + reloc in an unallocated section. */ + if (skip + || (input_section->flags & SEC_ALLOC) != 0 + || ELF32_R_TYPE (outrel.r_info) != R_SPARC_RELATIVE) + continue; } + break; default: break; } - if (r_type != R_SPARC_WDISP16) - r = _bfd_final_link_relocate (howto, input_bfd, input_section, - contents, rel->r_offset, - relocation, rel->r_addend); - else + if (r_type == R_SPARC_WDISP16) { bfd_vma x; @@ -1353,6 +1571,22 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section, else r = bfd_reloc_ok; } + else if (r_type == R_SPARC_REV32) + { + bfd_vma x; + + relocation = relocation + rel->r_addend; + + x = bfd_get_32 (input_bfd, contents + rel->r_offset); + x = x + relocation; + bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset); + r = bfd_reloc_ok; + } + else + r = _bfd_final_link_relocate (howto, input_bfd, input_section, + contents, rel->r_offset, + relocation, rel->r_addend); + if (r != bfd_reloc_ok) { @@ -1404,7 +1638,7 @@ elf32_sparc_finish_dynamic_symbol (output_bfd, info, h, sym) dynobj = elf_hash_table (info)->dynobj; - if (h->plt_offset != (bfd_vma) -1) + if (h->plt.offset != (bfd_vma) -1) { asection *splt; asection *srela; @@ -1421,24 +1655,24 @@ elf32_sparc_finish_dynamic_symbol (output_bfd, info, h, sym) /* Fill in the entry in the procedure linkage table. */ bfd_put_32 (output_bfd, - PLT_ENTRY_WORD0 + h->plt_offset, - splt->contents + h->plt_offset); + PLT_ENTRY_WORD0 + h->plt.offset, + splt->contents + h->plt.offset); bfd_put_32 (output_bfd, (PLT_ENTRY_WORD1 - + (((- (h->plt_offset + 4)) >> 2) & 0x3fffff)), - splt->contents + h->plt_offset + 4); + + (((- (h->plt.offset + 4)) >> 2) & 0x3fffff)), + splt->contents + h->plt.offset + 4); bfd_put_32 (output_bfd, PLT_ENTRY_WORD2, - splt->contents + h->plt_offset + 8); + splt->contents + h->plt.offset + 8); /* Fill in the entry in the .rela.plt section. */ rela.r_offset = (splt->output_section->vma + splt->output_offset - + h->plt_offset); + + h->plt.offset); rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_JMP_SLOT); rela.r_addend = 0; bfd_elf32_swap_reloca_out (output_bfd, &rela, ((Elf32_External_Rela *) srela->contents - + h->plt_offset / PLT_ENTRY_SIZE - 4)); + + h->plt.offset / PLT_ENTRY_SIZE - 4)); if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) { @@ -1448,7 +1682,7 @@ elf32_sparc_finish_dynamic_symbol (output_bfd, info, h, sym) } } - if (h->got_offset != (bfd_vma) -1) + if (h->got.offset != (bfd_vma) -1) { asection *sgot; asection *srela; @@ -1457,27 +1691,26 @@ elf32_sparc_finish_dynamic_symbol (output_bfd, info, h, sym) /* This symbol has an entry in the global offset table. Set it up. */ - BFD_ASSERT (h->dynindx != -1); - sgot = bfd_get_section_by_name (dynobj, ".got"); srela = bfd_get_section_by_name (dynobj, ".rela.got"); BFD_ASSERT (sgot != NULL && srela != NULL); rela.r_offset = (sgot->output_section->vma + sgot->output_offset - + (h->got_offset &~ 1)); + + (h->got.offset &~ 1)); /* If this is a -Bsymbolic link, and the symbol is defined - locally, we just want to emit a RELATIVE reloc. The entry in - the global offset table will already have been initialized in - the relocate_section function. */ + locally, we just want to emit a RELATIVE reloc. Likewise if + the symbol was forced to be local because of a version file. + The entry in the global offset table will already have been + initialized in the relocate_section function. */ if (info->shared - && info->symbolic + && (info->symbolic || h->dynindx == -1) && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)) rela.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE); else { - bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got_offset); + bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset); rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_GLOB_DAT); } @@ -1619,6 +1852,7 @@ elf32_sparc_finish_dynamic_sections (output_bfd, info) asection *sdynsym; asection *s; Elf_Internal_Sym sym; + int c; /* Set up the section symbols for the output sections. */ @@ -1630,10 +1864,14 @@ elf32_sparc_finish_dynamic_sections (output_bfd, info) sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION); sym.st_other = 0; + c = 0; for (s = output_bfd->sections; s != NULL; s = s->next) { int indx; + if (elf_section_data (s)->dynindx == 0) + continue; + sym.st_value = s->vma; indx = elf_section_data (s)->this_idx; @@ -1644,12 +1882,13 @@ elf32_sparc_finish_dynamic_sections (output_bfd, info) (PTR) (((Elf32_External_Sym *) sdynsym->contents) + elf_section_data (s)->dynindx)); + + ++c; } /* Set the sh_info field of the output .dynsym section to the index of the first global symbol. */ - elf_section_data (sdynsym->output_section)->this_hdr.sh_info = - bfd_count_sections (output_bfd) + 1; + elf_section_data (sdynsym->output_section)->this_hdr.sh_info = c + 1; } return true; @@ -1671,6 +1910,7 @@ elf32_sparc_merge_private_bfd_data (ibfd, obfd) bfd *obfd; { boolean error; + static int previous_ibfd_e_flags = -1; if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour || bfd_get_flavour (obfd) != bfd_target_elf_flavour) @@ -1692,7 +1932,7 @@ elf32_sparc_merge_private_bfd_data (ibfd, obfd) { error = true; (*_bfd_error_handler) - ("%s: compiled for a v8plus system and target is v8", + (_("%s: compiled for a v8plus system and target is v8"), bfd_get_filename (ibfd)); } /* If the output machine is v9, we can't allow v9+vis input files. */ @@ -1701,7 +1941,7 @@ elf32_sparc_merge_private_bfd_data (ibfd, obfd) { error = true; (*_bfd_error_handler) - ("%s: compiled for a v8plusa system and target is v8plus", + (_("%s: compiled for a v8plusa system and target is v8plus"), bfd_get_filename (ibfd)); } #else @@ -1709,13 +1949,24 @@ elf32_sparc_merge_private_bfd_data (ibfd, obfd) { error = true; (*_bfd_error_handler) - ("%s: compiled for a 64 bit system and target is 32 bit", + (_("%s: compiled for a 64 bit system and target is 32 bit"), bfd_get_filename (ibfd)); } else if (bfd_get_mach (obfd) < bfd_get_mach (ibfd)) bfd_set_arch_mach (obfd, bfd_arch_sparc, bfd_get_mach (ibfd)); #endif + if (((elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA) + != previous_ibfd_e_flags) + && previous_ibfd_e_flags >= 0) + { + (*_bfd_error_handler) + (_("%s: linking little endian files with big endian files"), + bfd_get_filename (ibfd)); + error = true; + } + previous_ibfd_e_flags = elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA; + if (error) { bfd_set_error (bfd_error_bad_value); @@ -1742,6 +1993,9 @@ elf32_sparc_object_p (abfd) else return false; } + else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA) + return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, + bfd_mach_sparc_sparclite_le); else return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc); } @@ -1768,8 +2022,13 @@ elf32_sparc_final_write_processing (abfd, linker) elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK; elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS | EF_SPARC_SUN_US1; break; + case bfd_mach_sparc_sparclite_le : + elf_elfheader (abfd)->e_machine = EM_SPARC; + elf_elfheader (abfd)->e_flags |= EF_SPARC_LEDATA; + break; default : abort (); + break; } } @@ -1799,8 +2058,14 @@ elf32_sparc_final_write_processing (abfd, linker) #define elf_backend_object_p elf32_sparc_object_p #define elf_backend_final_write_processing \ elf32_sparc_final_write_processing +#define elf_backend_gc_mark_hook elf32_sparc_gc_mark_hook +#define elf_backend_gc_sweep_hook elf32_sparc_gc_sweep_hook + +#define elf_backend_can_gc_sections 1 #define elf_backend_want_got_plt 0 #define elf_backend_plt_readonly 0 #define elf_backend_want_plt_sym 1 +#define elf_backend_got_header_size 4 +#define elf_backend_plt_header_size (4*PLT_ENTRY_SIZE) #include "elf32-target.h"