/* BFD back-end for HP PA-RISC ELF files.
- Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1999, 2000, 2001
- Free Software Foundation, Inc.
+ Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1999, 2000, 2001,
+ 2002 Free Software Foundation, Inc.
Original code by
Center for Software Science
#include "libhppa.h"
#include "elf32-hppa.h"
#define ARCH_SIZE 32
-#include "elf-hppa.h"
#include "elf32-hppa.h"
+#include "elf-hppa.h"
/* In order to gain some understanding of code in this file without
knowing all the intricate details of the linker, note the
asection *, const Elf_Internal_Rela *));
static void elf32_hppa_hide_symbol
- PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
+ PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *, boolean));
static boolean elf32_hppa_adjust_dynamic_symbol
PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
stub_entry = hppa_stub_hash_lookup (&htab->stub_hash_table,
stub_name, false, false);
- if (stub_entry == NULL)
- {
- if (hash == NULL || hash->elf.root.type != bfd_link_hash_undefweak)
- (*_bfd_error_handler) (_("%s(%s+0x%lx): cannot find stub entry %s"),
- bfd_archive_filename (input_section->owner),
- input_section->name,
- (long) rel->r_offset,
- stub_name);
- }
- else
- {
- if (hash != NULL)
- hash->stub_cache = stub_entry;
- }
+ if (hash != NULL)
+ hash->stub_cache = stub_entry;
free (stub_name);
}
}
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 bfd_section_from_elf_index (abfd, sym->st_shndx);
}
return NULL;
plabels. */
static void
-elf32_hppa_hide_symbol (info, h)
- struct bfd_link_info *info ATTRIBUTE_UNUSED;
+elf32_hppa_hide_symbol (info, h, force_local)
+ struct bfd_link_info *info;
struct elf_link_hash_entry *h;
+ boolean force_local;
{
- if ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0)
- h->dynindx = -1;
+ if (force_local)
+ {
+ h->elf_link_hash_flags |= ELF_LINK_FORCED_LOCAL;
+ if (h->dynindx != -1)
+ {
+ h->dynindx = -1;
+ _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
+ h->dynstr_index);
+ }
+ }
+
if (! ((struct elf32_hppa_link_hash_entry *) h)->plabel)
{
h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
struct elf_link_hash_entry *h;
struct bfd_link_info *info;
{
- /* We only want to remove these from the dynamic symbol table.
- Therefore we do not leave ELF_LINK_FORCED_LOCAL set. */
- if (h->type == STT_PARISC_MILLI)
+ if (h->type == STT_PARISC_MILLI
+ && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
{
- unsigned short oldflags = h->elf_link_hash_flags;
- h->elf_link_hash_flags |= ELF_LINK_FORCED_LOCAL;
- elf32_hppa_hide_symbol (info, h);
- h->elf_link_hash_flags &= ~ELF_LINK_FORCED_LOCAL;
- h->elf_link_hash_flags |= oldflags & ELF_LINK_FORCED_LOCAL;
+ elf32_hppa_hide_symbol (info, h, true);
}
return true;
}
linker script /DISCARD/, so we'll be discarding
the relocs too. */
}
- else
+ else if (p->count != 0)
{
srel = elf_section_data (p->sec)->sreloc;
srel->_raw_size += p->count * sizeof (Elf32_External_Rela);
+ if ((p->sec->output_section->flags & SEC_READONLY) != 0)
+ info->flags |= DF_TEXTREL;
}
}
}
/* If any dynamic relocs apply to a read-only section,
then we need a DT_TEXTREL entry. */
- elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, (PTR) info);
+ if ((info->flags & DF_TEXTREL) == 0)
+ elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
+ (PTR) info);
if ((info->flags & DF_TEXTREL) != 0)
{
if (stub_group_size == 1)
{
/* Default values. */
- stub_group_size = 8000000;
+ stub_group_size = 7680000;
if (htab->has_17bit_branch || htab->multi_subspace)
- stub_group_size = 250000;
+ stub_group_size = 240000;
if (htab->has_12bit_branch)
- stub_group_size = 7812;
+ stub_group_size = 7500;
}
/* Count the number of input BFDs and find the top input section id. */
curr = prev;
/* OK, the size from the start of CURR to the end is less
- than 250000 bytes and thus can be handled by one stub
+ than 240000 bytes and thus can be handled by one stub
section. (or the tail section is itself larger than
- 250000 bytes, in which case we may be toast.)
+ 240000 bytes, in which case we may be toast.)
We should really be keeping track of the total size of
stubs added here, as stubs contribute to the final output
section size. That's a little tricky, and this way will
- only break if stubs added total more than 12144 bytes, or
- 1518 long branch stubs. It seems unlikely for more than
- 1518 different functions to be called, especially from
- code only 250000 bytes long. */
+ only break if stubs added total more than 22144 bytes, or
+ 2768 long branch stubs. It seems unlikely for more than
+ 2768 different functions to be called, especially from
+ code only 240000 bytes long. This limit used to be
+ 250000, but c++ code tends to generate lots of little
+ functions, and sometimes violated the assumption. */
do
{
prev = PREV_SEC (tail);
}
while (tail != curr && (tail = prev) != NULL);
- /* But wait, there's more! Input sections up to 250000
+ /* But wait, there's more! Input sections up to 240000
bytes before the stub section can be handled by it too. */
if (!stubs_always_before_branch)
{
input_bfd = input_bfd->link_next, bfd_indx++)
{
Elf_Internal_Shdr *symtab_hdr;
+ Elf_Internal_Shdr *shndx_hdr;
Elf_Internal_Sym *isym;
Elf32_External_Sym *ext_syms, *esym, *end_sy;
+ Elf_External_Sym_Shndx *shndx_buf, *shndx;
bfd_size_type sec_size;
/* We'll need the symbol table in a second. */
sec_size *= sizeof (Elf_Internal_Sym);
local_syms = (Elf_Internal_Sym *) bfd_malloc (sec_size);
if (local_syms == NULL)
- {
- goto error_ret_free_local;
- }
+ goto error_ret_free_local;
+
all_local_syms[bfd_indx] = local_syms;
sec_size = symtab_hdr->sh_info;
sec_size *= sizeof (Elf32_External_Sym);
ext_syms = (Elf32_External_Sym *) bfd_malloc (sec_size);
if (ext_syms == NULL)
- {
- goto error_ret_free_local;
- }
+ goto error_ret_free_local;
if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
- || (bfd_bread (ext_syms, sec_size, input_bfd) != sec_size))
+ || bfd_bread ((PTR) ext_syms, sec_size, input_bfd) != sec_size)
{
+ error_ret_free_ext_syms:
free (ext_syms);
goto error_ret_free_local;
}
+ shndx_buf = NULL;
+ shndx_hdr = &elf_tdata (input_bfd)->symtab_shndx_hdr;
+ if (shndx_hdr->sh_size != 0)
+ {
+ sec_size = symtab_hdr->sh_info;
+ sec_size *= sizeof (Elf_External_Sym_Shndx);
+ shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (sec_size);
+ if (shndx_buf == NULL)
+ goto error_ret_free_ext_syms;
+
+ if (bfd_seek (input_bfd, shndx_hdr->sh_offset, SEEK_SET) != 0
+ || bfd_bread ((PTR) shndx_buf, sec_size, input_bfd) != sec_size)
+ {
+ free (shndx_buf);
+ goto error_ret_free_ext_syms;
+ }
+ }
+
/* Swap the local symbols in. */
- isym = local_syms;
- esym = ext_syms;
- for (end_sy = esym + symtab_hdr->sh_info; esym < end_sy; esym++, isym++)
- bfd_elf32_swap_symbol_in (input_bfd, esym, isym);
+ for (esym = ext_syms, end_sy = esym + symtab_hdr->sh_info,
+ isym = local_syms, shndx = shndx_buf;
+ esym < end_sy;
+ esym++, isym++, shndx = (shndx ? shndx + 1 : NULL))
+ bfd_elf32_swap_symbol_in (input_bfd, esym, shndx, isym);
/* Now we can free the external symbols. */
+ free (shndx_buf);
free (ext_syms);
if (info->shared && htab->multi_subspace)
/* Read in the external relocs. */
input_rel_hdr = &elf_section_data (section)->rel_hdr;
if (bfd_seek (input_bfd, input_rel_hdr->sh_offset, SEEK_SET) != 0
- || bfd_bread (external_relocs,
- input_rel_hdr->sh_size,
- input_bfd) != input_rel_hdr->sh_size)
+ || bfd_bread ((PTR) external_relocs,
+ input_rel_hdr->sh_size,
+ input_bfd) != input_rel_hdr->sh_size)
{
free (external_relocs);
error_ret_free_internal:
addend = 8;
}
else
- return bfd_reloc_notsupported;
+ return bfd_reloc_undefined;
}
/* Fall thru. */
r_field = e_fsel;
break;
- case R_PARISC_DIR21L:
+ case R_PARISC_DLTIND21L:
case R_PARISC_PCREL21L:
- case R_PARISC_DPREL21L:
case R_PARISC_PLABEL21L:
- case R_PARISC_DLTIND21L:
+ r_field = e_lsel;
+ break;
+
+ case R_PARISC_DIR21L:
+ case R_PARISC_DPREL21L:
r_field = e_lrsel;
break;
- case R_PARISC_DIR17R:
case R_PARISC_PCREL17R:
- case R_PARISC_DIR14R:
case R_PARISC_PCREL14R:
- case R_PARISC_DPREL14R:
case R_PARISC_PLABEL14R:
case R_PARISC_DLTIND14R:
+ r_field = e_rsel;
+ break;
+
+ case R_PARISC_DIR17R:
+ case R_PARISC_DIR14R:
+ case R_PARISC_DPREL14R:
r_field = e_rrsel;
break;
stub_entry = hppa_get_stub_entry (input_section, sym_sec,
h, rel, htab);
if (stub_entry == NULL)
- return bfd_reloc_notsupported;
+ return bfd_reloc_undefined;
/* Munge up the value and addend so that we call the stub
rather than the procedure directly. */
bfd_reloc_status_type r;
const char *sym_name;
boolean plabel;
+ boolean warned_undef;
r_type = ELF32_R_TYPE (rel->r_info);
if (r_type >= (unsigned int) R_PARISC_UNIMPLEMENTED)
h = NULL;
sym = NULL;
sym_sec = NULL;
+ warned_undef = false;
if (r_symndx < symtab_hdr->sh_info)
{
/* This is a local symbol, h defaults to NULL. */
sym = local_syms + r_symndx;
sym_sec = local_sections[r_symndx];
- relocation = ((ELF_ST_TYPE (sym->st_info) == STT_SECTION
- ? 0 : sym->st_value)
- + sym_sec->output_offset
- + sym_sec->output_section->vma);
+ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sym_sec, rel);
}
else
{
&& h->elf.type != STT_PARISC_MILLI)
{
if (info->symbolic && !info->allow_shlib_undefined)
- if (!((*info->callbacks->undefined_symbol)
- (info, h->elf.root.root.string, input_bfd,
- input_section, rel->r_offset, false)))
- return false;
+ {
+ if (!((*info->callbacks->undefined_symbol)
+ (info, h->elf.root.root.string, input_bfd,
+ input_section, rel->r_offset, false)))
+ return false;
+ warned_undef = true;
+ }
}
else
{
(info, h->elf.root.root.string, input_bfd,
input_section, rel->r_offset, true)))
return false;
+ warned_undef = true;
}
}
are copied into the output file to be resolved at run
time. */
- outrel.r_offset = rel->r_offset;
outrel.r_addend = rel->r_addend;
- skip = false;
- if (elf_section_data (input_section)->stab_info != NULL)
- {
- bfd_vma off;
-
- off = (_bfd_stab_section_offset
- (output_bfd, &htab->elf.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 =
+ _bfd_elf_section_offset (output_bfd, info, input_section,
+ rel->r_offset);
+ skip = (outrel.r_offset == (bfd_vma) -1
+ || outrel.r_offset == (bfd_vma) -2);
outrel.r_offset += (input_section->output_offset
+ input_section->output_section->vma);
if (r == bfd_reloc_undefined || r == bfd_reloc_notsupported)
{
- (*_bfd_error_handler)
- (_("%s(%s+0x%lx): cannot handle %s for %s"),
- bfd_archive_filename (input_bfd),
- input_section->name,
- (long) rel->r_offset,
- howto->name,
- sym_name);
- bfd_set_error (bfd_error_bad_value);
- return false;
+ if (r == bfd_reloc_notsupported || !warned_undef)
+ {
+ (*_bfd_error_handler)
+ (_("%s(%s+0x%lx): cannot handle %s for %s"),
+ bfd_archive_filename (input_bfd),
+ input_section->name,
+ (long) rel->r_offset,
+ howto->name,
+ sym_name);
+ bfd_set_error (bfd_error_bad_value);
+ return false;
+ }
}
else
{
projects / deliverable / binutils-gdb.git / blobdiff