diff options
| -rw-r--r-- | bfd/ChangeLog | 10 | ||||
| -rw-r--r-- | bfd/elf64-alpha.c | 229 |
2 files changed, 154 insertions, 85 deletions
diff --git a/bfd/ChangeLog b/bfd/ChangeLog index 546fd5ec..87e62af 100644 --- a/bfd/ChangeLog +++ b/bfd/ChangeLog @@ -1,5 +1,15 @@ 2002-06-01 Richard Henderson <rth@redhat.com> + * elf64-alpha.c (elf64_alpha_relax_with_lituse): Don't test for + undefined symbols here. + (elf64_alpha_relax_section): Do it here. Also test for not + defined in the current module. + (elf64_alpha_relocate_section_r): Split out of ... + (elf64_alpha_relocate_section): ... here. Don't dereference + NULL when looking up local got entries. + +2002-06-01 Richard Henderson <rth@redhat.com> + * elf64-alpha.c (elf64_alpha_relax_with_lituse): Reject undefined symbols from JSR relaxation. (elf64_alpha_size_plt_section_1): New. diff --git a/bfd/elf64-alpha.c b/bfd/elf64-alpha.c index 6370d54..bdae249 100644 --- a/bfd/elf64-alpha.c +++ b/bfd/elf64-alpha.c @@ -134,6 +134,9 @@ static boolean elf64_alpha_adjust_dynamic_symbol PARAMS((struct bfd_link_info *, struct elf_link_hash_entry *)); static boolean elf64_alpha_size_dynamic_sections PARAMS((bfd *, struct bfd_link_info *)); +static boolean elf64_alpha_relocate_section_r + PARAMS((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, + Elf_Internal_Rela *, Elf_Internal_Sym *, asection **)); static boolean elf64_alpha_relocate_section PARAMS((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Sym *, asection **)); @@ -1399,15 +1402,6 @@ elf64_alpha_relax_with_lituse (info, symval, irel) bfd_vma optdest, org; bfd_signed_vma odisp; - /* If this symbol is undefined, we can't relax it to a branch. */ - if (info->h - && (info->h->root.root.type == bfd_link_hash_undefweak - || info->h->root.root.type == bfd_link_hash_undefined)) - { - all_optimized = false; - break; - } - /* If not zero, place to jump without needing pv. */ optdest = elf64_alpha_relax_opt_call (info, symval); org = (info->sec->output_section->vma @@ -2181,7 +2175,7 @@ elf64_alpha_relax_section (abfd, sec, link_info, again) shndx = shndx_buf + (shndx_buf ? ELF64_R_SYM (irel->r_info) : 0); bfd_elf64_swap_symbol_in (abfd, esym, shndx, &isym); if (isym.st_shndx == SHN_UNDEF) - info.tsec = bfd_und_section_ptr; + continue; else if (isym.st_shndx == SHN_ABS) info.tsec = bfd_abs_section_ptr; else if (isym.st_shndx == SHN_COMMON) @@ -2207,6 +2201,16 @@ elf64_alpha_relax_section (abfd, sec, link_info, again) || h->root.root.type == bfd_link_hash_warning) h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link; + /* If the symbol is undefined, we can't do anything with it. */ + if (h->root.root.type == bfd_link_hash_undefweak + || h->root.root.type == bfd_link_hash_undefined) + continue; + + /* If the symbol isn't defined in the current module, again + we can't do anything. */ + if (!(h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)) + continue; + info.h = h; info.tsec = h->root.root.u.def.section; info.other = h->root.other; @@ -4173,6 +4177,71 @@ elf64_alpha_size_dynamic_sections (output_bfd, info) return true; } +/* Relocate an Alpha ELF section for a relocatable link. + + We don't have to change anything unless the reloc is against a section + symbol, in which case we have to adjust according to where the section + symbol winds up in the output section. */ + +static boolean +elf64_alpha_relocate_section_r (output_bfd, info, input_bfd, input_section, + contents, relocs, local_syms, local_sections) + bfd *output_bfd ATTRIBUTE_UNUSED; + struct bfd_link_info *info ATTRIBUTE_UNUSED; + bfd *input_bfd; + asection *input_section; + bfd_byte *contents ATTRIBUTE_UNUSED; + Elf_Internal_Rela *relocs; + Elf_Internal_Sym *local_syms; + asection **local_sections; +{ + unsigned long symtab_hdr_sh_info; + Elf_Internal_Rela *rel; + Elf_Internal_Rela *relend; + boolean ret_val = true; + + symtab_hdr_sh_info = elf_tdata (input_bfd)->symtab_hdr.sh_info; + + relend = relocs + input_section->reloc_count; + for (rel = relocs; rel < relend; rel++) + { + unsigned long r_symndx; + Elf_Internal_Sym *sym; + asection *sec; + unsigned long r_type; + + r_type = ELF64_R_TYPE(rel->r_info); + if (r_type >= R_ALPHA_max) + { + (*_bfd_error_handler) + (_("%s: unknown relocation type %d"), + bfd_archive_filename (input_bfd), (int)r_type); + bfd_set_error (bfd_error_bad_value); + ret_val = false; + continue; + } + + r_symndx = ELF64_R_SYM(rel->r_info); + + /* The symbol associated with GPDISP and LITUSE is + immaterial. Only the addend is significant. */ + if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE) + continue; + + if (r_symndx < symtab_hdr_sh_info) + { + sym = local_syms + r_symndx; + if (ELF_ST_TYPE(sym->st_info) == STT_SECTION) + { + sec = local_sections[r_symndx]; + rel->r_addend += sec->output_offset + sym->st_value; + } + } + } + + return ret_val; +} + /* Relocate an Alpha ELF section. */ static boolean @@ -4187,67 +4256,86 @@ elf64_alpha_relocate_section (output_bfd, info, input_bfd, input_section, Elf_Internal_Sym *local_syms; asection **local_sections; { - Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; + Elf_Internal_Shdr *symtab_hdr; Elf_Internal_Rela *rel; Elf_Internal_Rela *relend; - struct elf_link_tls_segment *tls_segment = NULL; - asection *sgot = NULL, *srel = NULL, *srelgot = NULL; - bfd *dynobj = NULL, *gotobj = NULL; - bfd_vma gp = 0, tp_base = 0, dtp_base = 0; - boolean ret_val = true; + struct elf_link_tls_segment *tls_segment; + asection *sgot, *srel, *srelgot; + bfd *dynobj, *gotobj; + bfd_vma gp, tp_base, dtp_base; + struct alpha_elf_got_entry **local_got_entries; + boolean ret_val; + const char *section_name; - if (!info->relocateable) - { - const char *name; + /* Handle relocatable links with a smaller loop. */ + if (info->relocateable) + return elf64_alpha_relocate_section_r (output_bfd, info, input_bfd, + input_section, contents, relocs, + local_syms, local_sections); + + /* This is a final link. */ + + ret_val = true; - dynobj = elf_hash_table (info)->dynobj; - if (dynobj) - srelgot = bfd_get_section_by_name (dynobj, ".rela.got"); + symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; + + dynobj = elf_hash_table (info)->dynobj; + if (dynobj) + srelgot = bfd_get_section_by_name (dynobj, ".rela.got"); + else + srelgot = NULL; - name = (bfd_elf_string_from_elf_section - (input_bfd, elf_elfheader(input_bfd)->e_shstrndx, - elf_section_data(input_section)->rel_hdr.sh_name)); - BFD_ASSERT(name != NULL); - srel = bfd_get_section_by_name (dynobj, name); + section_name = (bfd_elf_string_from_elf_section + (input_bfd, elf_elfheader(input_bfd)->e_shstrndx, + elf_section_data(input_section)->rel_hdr.sh_name)); + BFD_ASSERT(section_name != NULL); + srel = bfd_get_section_by_name (dynobj, section_name); - /* Find the gp value for this input bfd. */ - gotobj = alpha_elf_tdata (input_bfd)->gotobj; - if (gotobj) + /* Find the gp value for this input bfd. */ + gotobj = alpha_elf_tdata (input_bfd)->gotobj; + if (gotobj) + { + sgot = alpha_elf_tdata (gotobj)->got; + gp = _bfd_get_gp_value (gotobj); + if (gp == 0) { - sgot = alpha_elf_tdata (gotobj)->got; - gp = _bfd_get_gp_value (gotobj); - if (gp == 0) - { - gp = (sgot->output_section->vma - + sgot->output_offset - + 0x8000); - _bfd_set_gp_value (gotobj, gp); - } - } + gp = (sgot->output_section->vma + + sgot->output_offset + + 0x8000); + _bfd_set_gp_value (gotobj, gp); + } + } + else + { + sgot = NULL; + gp = 0; + } - tls_segment = elf_hash_table (info)->tls_segment; - if (tls_segment) - { - dtp_base = alpha_get_dtprel_base (tls_segment); - tp_base = alpha_get_tprel_base (tls_segment); - } + local_got_entries = alpha_elf_tdata(input_bfd)->local_got_entries; + + tls_segment = elf_hash_table (info)->tls_segment; + if (tls_segment) + { + dtp_base = alpha_get_dtprel_base (tls_segment); + tp_base = alpha_get_tprel_base (tls_segment); } + else + dtp_base = tp_base = 0; - rel = relocs; relend = relocs + input_section->reloc_count; - for (; rel < relend; rel++) + for (rel = relocs; rel < relend; rel++) { - struct alpha_elf_link_hash_entry *h; + struct alpha_elf_link_hash_entry *h = NULL; struct alpha_elf_got_entry *gotent; bfd_reloc_status_type r; reloc_howto_type *howto; unsigned long r_symndx; - Elf_Internal_Sym *sym; - asection *sec; + Elf_Internal_Sym *sym = NULL; + asection *sec = NULL; bfd_vma value; bfd_vma addend; boolean dynamic_symbol_p; - boolean undef_weak_ref; + boolean undef_weak_ref = false; unsigned long r_type; r_type = ELF64_R_TYPE(rel->r_info); @@ -4264,45 +4352,16 @@ elf64_alpha_relocate_section (output_bfd, info, input_bfd, input_section, howto = elf64_alpha_howto_table + r_type; r_symndx = ELF64_R_SYM(rel->r_info); - if (info->relocateable) - { - /* This is a relocateable link. We don't have to change - anything, unless the reloc is against a section symbol, - in which case we have to adjust according to where the - section symbol winds up in the output section. */ - - /* The symbol associated with GPDISP and LITUSE is - immaterial. Only the addend is significant. */ - if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE) - continue; - - if (r_symndx < symtab_hdr->sh_info) - { - sym = local_syms + r_symndx; - if (ELF_ST_TYPE(sym->st_info) == STT_SECTION) - { - sec = local_sections[r_symndx]; - rel->r_addend += sec->output_offset + sym->st_value; - } - } - - continue; - } - - /* This is a final link. */ - - h = NULL; - sym = NULL; - sec = NULL; - undef_weak_ref = false; - if (r_symndx < symtab_hdr->sh_info) { sym = local_syms + r_symndx; sec = local_sections[r_symndx]; value = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel); - gotent = alpha_elf_tdata(input_bfd)->local_got_entries[r_symndx]; + if (local_got_entries) + gotent = local_got_entries[r_symndx]; + else + gotent = NULL; /* Need to adjust local GOT entries' addends for SEC_MERGE unless it has been done already. */ |