static void ppc_elf_info_to_howto
PARAMS ((bfd *abfd, arelent *cache_ptr, Elf32_Internal_Rela *dst));
static void ppc_elf_howto_init PARAMS ((void));
+static bfd_reloc_status_type ppc_elf_addr16_ha_reloc
+ PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
static boolean ppc_elf_set_private_flags PARAMS ((bfd *, flagword));
static boolean ppc_elf_copy_private_bfd_data PARAMS ((bfd *, bfd *));
static boolean ppc_elf_merge_private_bfd_data PARAMS ((bfd *, bfd *));
+static int ppc_elf_additional_program_headers PARAMS ((bfd *));
+static boolean ppc_elf_modify_segment_map PARAMS ((bfd *));
+
static boolean ppc_elf_section_from_shdr PARAMS ((bfd *,
Elf32_Internal_Shdr *,
char *));
Elf_Internal_Sym *local_syms,
asection **));
+static boolean ppc_elf_add_symbol_hook PARAMS ((bfd *,
+ struct bfd_link_info *,
+ const Elf_Internal_Sym *,
+ const char **,
+ flagword *,
+ asection **,
+ bfd_vma *));
+
static boolean ppc_elf_finish_dynamic_symbol PARAMS ((bfd *,
struct bfd_link_info *,
struct elf_link_hash_entry *,
static boolean ppc_elf_finish_dynamic_sections PARAMS ((bfd *, struct bfd_link_info *));
-#define BRANCH_PREDICT_BIT 0x200000
+#define BRANCH_PREDICT_BIT 0x200000 /* branch prediction bit for branch taken relocs */
+#define RA_REGISTER_MASK 0x001f0000 /* mask to set RA in memory instructions */
+#define RA_REGISTER_SHIFT 16 /* value to shift register by to insert RA */
/* The name of the dynamic interpreter. This is put in the .interp
section. */
#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
+/* The size in bytes of an entry in the procedure linkage table, and of the initial size
+ of the plt reserved for the dynamic linker. */
+
+#define PLT_ENTRY_SIZE 12
+#define PLT_INITIAL_ENTRY_SIZE 72
+
\f
static reloc_howto_type *ppc_elf_howto_table[ (int)R_PPC_max ];
false, /* pc_relative */
0, /* bitpos */
complain_overflow_dont, /* complain_on_overflow */
- bfd_elf_generic_reloc, /* special_function */
+ ppc_elf_addr16_ha_reloc, /* special_function */
"R_PPC_ADDR16_HA", /* name */
false, /* partial_inplace */
0, /* src_mask */
false), /* pcrel_offset */
/* Like R_PPC_ADDR16_HA, but referring to the GOT table entry for
- the symbol. FIXME: Not supported. */
+ the symbol. */
HOWTO (R_PPC_GOT16_HA, /* type */
0, /* rightshift */
1, /* size (0 = byte, 1 = short, 2 = long) */
false), /* pcrel_offset */
/* A sign-extended 16 bit value relative to _SDA_BASE_, for use with
- small data items. FIXME: Not supported. */
+ small data items. */
HOWTO (R_PPC_SDAREL16, /* type */
0, /* rightshift */
1, /* size (0 = byte, 1 = short, 2 = long) */
0xffff, /* dst_mask */
false), /* pcrel_offset */
- /* 32-bit section relative relocation. FIXME: not supported. */
+ /* 32-bit section relative relocation. */
HOWTO (R_PPC_SECTOFF, /* type */
0, /* rightshift */
2, /* size (0 = byte, 1 = short, 2 = long) */
0, /* dst_mask */
true), /* pcrel_offset */
- /* 16-bit lower half section relative relocation. FIXME: not supported. */
+ /* 16-bit lower half section relative relocation. */
HOWTO (R_PPC_SECTOFF_LO, /* type */
0, /* rightshift */
1, /* size (0 = byte, 1 = short, 2 = long) */
0xffff, /* dst_mask */
false), /* pcrel_offset */
- /* 16-bit upper half section relative relocation. FIXME: not supported. */
+ /* 16-bit upper half section relative relocation. */
HOWTO (R_PPC_SECTOFF_HI, /* type */
16, /* rightshift */
1, /* size (0 = byte, 1 = short, 2 = long) */
0xffff, /* dst_mask */
false), /* pcrel_offset */
- /* 16-bit upper half adjusted section relative relocation. FIXME: not supported. */
+ /* 16-bit upper half adjusted section relative relocation. */
HOWTO (R_PPC_SECTOFF_HA, /* type */
0, /* rightshift */
1, /* size (0 = byte, 1 = short, 2 = long) */
false), /* pcrel_offset */
/* A sign-extended 16 bit value relative to _SDA2_BASE_, for use with
- small data items. FIXME: Not supported. */
+ small data items. */
HOWTO (R_PPC_EMB_SDA2REL, /* type */
0, /* rightshift */
1, /* size (0 = byte, 1 = short, 2 = long) */
field with the appropriate register (0, 2, or 13). */
HOWTO (R_PPC_EMB_SDA21, /* type */
0, /* rightshift */
- 1, /* size (0 = byte, 1 = short, 2 = long) */
+ 2, /* size (0 = byte, 1 = short, 2 = long) */
16, /* bitsize */
false, /* pc_relative */
0, /* bitpos */
cache_ptr->howto = ppc_elf_howto_table[ELF32_R_TYPE (dst->r_info)];
}
+/* Handle the R_PPC_ADDR16_HA reloc. */
+
+static bfd_reloc_status_type
+ppc_elf_addr16_ha_reloc (abfd, reloc_entry, symbol, data, input_section,
+ output_bfd, error_message)
+ bfd *abfd;
+ arelent *reloc_entry;
+ asymbol *symbol;
+ PTR data;
+ asection *input_section;
+ bfd *output_bfd;
+ char **error_message;
+{
+ bfd_vma relocation;
+
+ if (output_bfd != NULL)
+ {
+ reloc_entry->address += input_section->output_offset;
+ return bfd_reloc_ok;
+ }
+
+ if (reloc_entry->address > input_section->_cooked_size)
+ return bfd_reloc_outofrange;
+
+ if (bfd_is_com_section (symbol->section))
+ relocation = 0;
+ else
+ relocation = symbol->value;
+
+ relocation += symbol->section->output_section->vma;
+ relocation += symbol->section->output_offset;
+ relocation += reloc_entry->addend;
+
+ reloc_entry->addend += (relocation & 0x8000) << 1;
+
+ return bfd_reloc_continue;
+}
+
/* Function to set whether a module needs the -mrelocatable bit set. */
static boolean
else if ((new_flags & EF_PPC_RELOCATABLE_LIB) != 0)
elf_elfheader (obfd)->e_flags |= EF_PPC_RELOCATABLE_LIB;
- new_flags &= ~ (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB);
- old_flags &= ~ (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB);
- /* Warn about eabi vs. V.4 mismatch */
- if ((new_flags & EF_PPC_EMB) != 0 && (old_flags & EF_PPC_EMB) == 0)
- {
- new_flags &= ~EF_PPC_EMB;
- error = true;
- (*_bfd_error_handler)
- ("%s: compiled for the eabi and linked with modules compiled for System V",
- bfd_get_filename (ibfd));
- }
- else if ((new_flags & EF_PPC_EMB) == 0 && (old_flags & EF_PPC_EMB) != 0)
- {
- old_flags &= ~EF_PPC_EMB;
- error = true;
- (*_bfd_error_handler)
- ("%s: compiled for System V and linked with modules compiled for eabi",
- bfd_get_filename (ibfd));
- }
+ /* Do not warn about eabi vs. V.4 mismatch, just or in the bit if any module uses it */
+ elf_elfheader (obfd)->e_flags |= (new_flags & EF_PPC_EMB);
+
+ new_flags &= ~ (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB);
+ old_flags &= ~ (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB);
/* Warn about any other mismatches */
if (new_flags != old_flags)
if ((asect->flags & SEC_SORT_ENTRIES) != 0)
shdr->sh_type = SHT_ORDERED;
+
+ return true;
}
\f
defaults.sym_offset = 4;
break;
+ case LINKER_SECTION_PLT: /* .plt section */
+ defaults.name = ".plt";
+ defaults.rel_name = ".rela.plt";
+ defaults.sym_name = (char *)0;
+ defaults.max_hole_offset = 0;
+ defaults.hole_size = 0;
+ defaults.sym_offset = 0;
+ defaults.flags &= ~SEC_LOAD;
+ break;
+
case LINKER_SECTION_SDATA: /* .sdata/.sbss section */
defaults.name = ".sdata";
defaults.rel_name = ".rela.sdata";
defaults.bss_name = ".sbss";
defaults.sym_name = "_SDA_BASE_";
+ defaults.sym_offset = 32768;
break;
case LINKER_SECTION_SDATA2: /* .sdata2/.sbss2 section */
defaults.rel_name = ".rela.sdata2";
defaults.bss_name = ".sbss2";
defaults.sym_name = "_SDA2_BASE_";
+ defaults.sym_offset = 32768;
+ defaults.flags |= SEC_READONLY;
break;
}
return lsect;
}
+\f
+/* If we have a non-zero sized .sbss2 or .PPC.EMB.sbss0 sections, we need to bump up
+ the number of section headers. */
+
+static int
+ppc_elf_additional_program_headers (abfd)
+ bfd *abfd;
+{
+ asection *s;
+ int ret;
+
+ ret = 0;
+
+ s = bfd_get_section_by_name (abfd, ".interp");
+ if (s != NULL)
+ ++ret;
+
+ s = bfd_get_section_by_name (abfd, ".sbss2");
+ if (s != NULL && (s->flags & SEC_LOAD) != 0 && s->_raw_size > 0)
+ ++ret;
+
+ s = bfd_get_section_by_name (abfd, ".PPC.EMB.sbss0");
+ if (s != NULL && (s->flags & SEC_LOAD) != 0 && s->_raw_size > 0)
+ ++ret;
+
+ return ret;
+}
+
+/* Modify the segment map if needed */
+
+static boolean
+ppc_elf_modify_segment_map (abfd)
+ bfd *abfd;
+{
+ return true;
+}
\f
/* Adjust a symbol defined by a dynamic object and referenced by a
regular object. The current definition is in some section of the
struct bfd_link_info *info;
struct elf_link_hash_entry *h;
{
+ bfd *dynobj = elf_hash_table (info)->dynobj;
+ asection *s;
+ unsigned int power_of_two;
+ bfd_vma plt_offset;
+
#ifdef DEBUG
- fprintf (stderr, "ppc_elf_adjust_dynamic_symbol called\n");
+ fprintf (stderr, "ppc_elf_adjust_dynamic_symbol called for %s\n", h->root.root.string);
#endif
+
+ /* Make sure we know what is going on here. */
+ BFD_ASSERT (dynobj != NULL
+ && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
+ || h->weakdef != NULL
+ || ((h->elf_link_hash_flags
+ & ELF_LINK_HASH_DEF_DYNAMIC) != 0
+ && (h->elf_link_hash_flags
+ & ELF_LINK_HASH_REF_REGULAR) != 0
+ && (h->elf_link_hash_flags
+ & ELF_LINK_HASH_DEF_REGULAR) == 0)));
+
+
+ /* If this is a function, put it in the procedure linkage table. We
+ will fill in the contents of the procedure linkage table later,
+ when we know the address of the .got section. */
+ if (h->type == STT_FUNC
+ || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
+ {
+ if (! info->shared
+ && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
+ && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
+ {
+ /* This case can occur if we saw a PLT32 reloc in an input
+ file, but the symbol was never referred to by a dynamic
+ object. In such a case, we don't actually need to build
+ a procedure linkage table, and we can just do a PC32
+ reloc instead. */
+ BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
+ return true;
+ }
+
+ /* Make sure this symbol is output as a dynamic symbol. */
+ if (h->dynindx == -1)
+ {
+ if (! bfd_elf32_link_record_dynamic_symbol (info, h))
+ return false;
+ }
+
+ s = bfd_get_section_by_name (dynobj, ".plt");
+ BFD_ASSERT (s != NULL);
+
+ /* If this is the first .plt entry, make room for the special
+ first entry. */
+ if (s->_raw_size == 0)
+ s->_raw_size += PLT_INITIAL_ENTRY_SIZE;
+
+ /* The PowerPC PLT is actually composed of two parts, the first part
+ is 2 words (for a load and a jump), and then there is a remaining
+ word available at the end. */
+ plt_offset = (PLT_INITIAL_ENTRY_SIZE
+ + 8 * ((s->_raw_size - PLT_INITIAL_ENTRY_SIZE) / PLT_ENTRY_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 = plt_offset;
+ }
+
+ h->plt_offset = plt_offset;
+
+ /* Make room for this entry. */
+ s->_raw_size += PLT_ENTRY_SIZE;
+
+ /* We also need to make an entry in the .rela.plt section. */
+
+ s = bfd_get_section_by_name (dynobj, ".rela.plt");
+ BFD_ASSERT (s != NULL);
+ s->_raw_size += sizeof (Elf32_External_Rela);
+
+ return true;
+ }
+
+ /* If this is a weak symbol, and there is a real definition, the
+ processor independent code will have arranged for us to see the
+ real definition first, and we can just use the same value. */
+ if (h->weakdef != NULL)
+ {
+ BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
+ || h->weakdef->root.type == bfd_link_hash_defweak);
+ h->root.u.def.section = h->weakdef->root.u.def.section;
+ h->root.u.def.value = h->weakdef->root.u.def.value;
+ return true;
+ }
+
+ /* This is a reference to a symbol defined by a dynamic object which
+ is not a function. */
+
+ /* If we are creating a shared library, we must presume that the
+ only references to the symbol are via the global offset table.
+ For such cases we need not do anything here; the relocations will
+ be handled correctly by relocate_section. */
+ if (info->shared)
+ return true;
+
+ /* We must allocate the symbol in our .dynbss section, which will
+ become part of the .bss section of the executable. There will be
+ an entry for this symbol in the .dynsym section. The dynamic
+ object will contain position independent code, so all references
+ from the dynamic object to this symbol will go through the global
+ offset table. The dynamic linker will use the .dynsym entry to
+ determine the address it must put in the global offset table, so
+ both the dynamic object and the regular object will refer to the
+ same memory location for the variable. */
+
+ 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_PPC_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 .rela.bss section
+ we are going to use. */
+ if ((h->root.u.def.section->flags & SEC_LOAD) != 0)
+ {
+ asection *srel;
+
+ srel = bfd_get_section_by_name (dynobj, ".rela.bss");
+ BFD_ASSERT (srel != NULL);
+ srel->_raw_size += sizeof (Elf32_External_Rel);
+ h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
+ }
+
+ /* We need to figure out the alignment required for this symbol. I
+ have no idea how ELF linkers handle this. */
+ power_of_two = bfd_log2 (h->size);
+ if (power_of_two > 3)
+ power_of_two = 3;
+
+ /* Apply the required alignment. */
+ s->_raw_size = BFD_ALIGN (s->_raw_size,
+ (bfd_size_type) (1 << power_of_two));
+ if (power_of_two > bfd_get_section_alignment (dynobj, s))
+ {
+ if (! bfd_set_section_alignment (dynobj, s, power_of_two))
+ return false;
+ }
+
+ /* Define the symbol as being at this point in the section. */
+ h->root.u.def.section = s;
+ h->root.u.def.value = s->_raw_size;
+
+ /* Increment the section size to make room for the symbol. */
+ s->_raw_size += h->size;
+
return true;
}
{
bfd *dynobj;
asection *s;
+ boolean plt;
+ boolean relocs;
boolean reltext;
- boolean relplt;
#ifdef DEBUG
fprintf (stderr, "ppc_elf_size_dynamic_sections called\n");
/* The check_relocs and adjust_dynamic_symbol entry points have
determined the sizes of the various dynamic sections. Allocate
memory for them. */
+ plt = false;
+ relocs = false;
reltext = false;
- relplt = false;
for (s = dynobj->sections; s != NULL; s = s->next)
{
const char *name;
strip = false;
- if (strncmp (name, ".rela", 5) == 0)
+ if (strcmp (name, ".plt") == 0)
+ {
+ if (s->_raw_size == 0)
+ {
+ /* Strip this section if we don't need it; see the
+ comment below. */
+ strip = true;
+ }
+ else
+ {
+ /* Remember whether there is a PLT. */
+ plt = true;
+ }
+ }
+ else if (strncmp (name, ".rela", 5) == 0)
{
if (s->_raw_size == 0)
{
/* If we don't need this section, strip it from the
- output file. This is to handle .rela.bss and
- .rel.plt. We must create it in
- create_dynamic_sections, because it must be created
+ output file. This is mostly to handle .rela.bss and
+ .rela.plt. We must create both sections in
+ create_dynamic_sections, because they must be created
before the linker maps input sections to output
sections. The linker does that before
adjust_dynamic_symbol is called, and it is that
{
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);
- if (target != NULL
- && (target->flags & SEC_READONLY) != 0)
- reltext = true;
-
- if (strcmp (name, ".rela.plt") == 0)
- relplt = true;
+ /* Remember whether there are any reloc sections other
+ than .rel.plt. */
+ if (strcmp (name, ".rela.plt") != 0)
+ {
+ relocs = true;
+
+ /* If this relocation section applies to a read only
+ section, then we probably need a DT_TEXTREL
+ entry. The entries in the .rel.plt section
+ really apply to the .got section, which we
+ created ourselves and so know is not readonly. */
+ target = bfd_get_section_by_name (output_bfd, name + 4);
+ if (target != NULL
+ && (target->flags & SEC_READONLY) != 0)
+ reltext = true;
+ }
/* We use the reloc_count field as a counter if we need
to copy relocs into the output file. */
s->reloc_count = 0;
}
}
- else if (strcmp (name, ".plt") != 0
- && strcmp (name, ".got") != 0)
+ else if (strcmp (name, ".got") != 0
+ && strcmp (name, ".sdata") != 0
+ && strcmp (name, ".sdata2") != 0)
{
/* It's not one of our sections, so don't allocate space. */
continue;
}
/* Allocate memory for the section contents. */
- s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
+ s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
if (s->contents == NULL && s->_raw_size != 0)
return false;
}
return false;
}
- if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0))
- return false;
-
- if (relplt)
+ if (plt)
{
- if (! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
- || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
+ 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_REL)
|| ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
return false;
}
- if (! bfd_elf32_add_dynamic_entry (info, DT_RELA, 0)
- || ! bfd_elf32_add_dynamic_entry (info, DT_RELASZ, 0)
- || ! bfd_elf32_add_dynamic_entry (info, DT_RELAENT,
- sizeof (Elf32_External_Rela)))
- return false;
+ if (relocs)
+ {
+ if (! bfd_elf32_add_dynamic_entry (info, DT_RELA, 0)
+ || ! bfd_elf32_add_dynamic_entry (info, DT_RELASZ, DT_RELA)
+ || ! bfd_elf32_add_dynamic_entry (info, DT_RELENT,
+ sizeof (Elf32_External_Rela)))
+ return false;
+ }
if (reltext)
{
asection *sec;
const Elf_Internal_Rela *relocs;
{
+ boolean ret = true;
bfd *dynobj;
Elf_Internal_Shdr *symtab_hdr;
struct elf_link_hash_entry **sym_hashes;
const Elf_Internal_Rela *rel;
const Elf_Internal_Rela *rel_end;
elf_linker_section_t *got;
+ elf_linker_section_t *plt;
elf_linker_section_t *sdata;
elf_linker_section_t *sdata2;
asection *sreloc;
return true;
#ifdef DEBUG
- fprintf (stderr, "ppc_elf_check_relocs called for section %s\n", sec->name);
+ fprintf (stderr, "ppc_elf_check_relocs called for section %s in %s\n",
+ bfd_get_section_name (abfd, sec),
+ bfd_get_filename (abfd));
#endif
/* Create the linker generated sections all the time so that the special
{
got = ppc_elf_create_linker_section (abfd, info, LINKER_SECTION_GOT);
if (!got)
- return false;
+ ret = false;
}
+#if 0
+ if ((plt = elf_linker_section (abfd, LINKER_SECTION_PLT)) == NULL)
+ {
+ plt = ppc_elf_create_linker_section (abfd, info, LINKER_SECTION_PLT);
+ if (!plt)
+ ret = false;
+ }
+#endif
+
if ((sdata = elf_linker_section (abfd, LINKER_SECTION_SDATA)) == NULL)
{
sdata = ppc_elf_create_linker_section (abfd, info, LINKER_SECTION_SDATA);
if (!sdata)
- return false;
+ ret = false;
}
{
sdata2 = ppc_elf_create_linker_section (abfd, info, LINKER_SECTION_SDATA2);
if (!sdata2)
- return false;
+ ret = false;
}
dynobj = elf_hash_table (info)->dynobj;
switch (ELF32_R_TYPE (rel->r_info))
{
- default:
- break;
-
/* GOT16 relocations */
case R_PPC_GOT16:
case R_PPC_GOT16_LO:
if (got->rel_section == NULL
&& (h != NULL || info->shared)
&& !_bfd_elf_make_linker_section_rela (dynobj, got, 2))
- return false;
+ {
+ ret = false;
+ break;
+ }
if (!bfd_elf32_create_pointer_linker_section (abfd, info, got, h, rel))
- return false;
+ ret = false;
break;
/* Indirect .sdata relocation */
case R_PPC_EMB_SDAI16:
+ if (info->shared)
+ {
+ (*_bfd_error_handler) ("%s: relocation %s cannot be used when making a shared object",
+ bfd_get_filename (abfd),
+ "R_PPC_EMB_SDAI16");
+ ret = false;
+ break;
+ }
+
if (got->rel_section == NULL
&& (h != NULL || info->shared)
&& !_bfd_elf_make_linker_section_rela (dynobj, got, 2))
- return false;
+ {
+ ret = false;
+ break;
+ }
- BFD_ASSERT (!info->shared);
if (!bfd_elf32_create_pointer_linker_section (abfd, info, sdata, h, rel))
- return false;
+ ret = false;
break;
/* Indirect .sdata2 relocation */
case R_PPC_EMB_SDA2I16:
+ if (info->shared)
+ {
+ (*_bfd_error_handler) ("%s: relocation %s cannot be used when making a shared object",
+ bfd_get_filename (abfd),
+ "R_PPC_EMB_SDA2I16");
+ ret = false;
+ break;
+ }
+
if (got->rel_section == NULL
&& (h != NULL || info->shared)
&& !_bfd_elf_make_linker_section_rela (dynobj, got, 2))
return false;
- BFD_ASSERT (!info->shared);
if (!bfd_elf32_create_pointer_linker_section (abfd, info, sdata2, h, rel))
return false;
break;
-#if 0
+ case R_PPC_SDAREL16:
+ case R_PPC_EMB_SDA2REL:
+ case R_PPC_EMB_SDA21:
+ if (info->shared)
+ {
+ (*_bfd_error_handler) ("%s: relocation %s cannot be used when making a shared object",
+ bfd_get_filename (abfd),
+ ppc_elf_howto_table[(int)ELF32_R_TYPE (rel->r_info)]->name);
+ ret = false;
+ }
+ break;
+
case R_PPC_PLT32:
case R_PPC_PLTREL24:
case R_PPC_PLT16_LO:
/* 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;
+ ret = false;
+ break;
}
/* Make sure this symbol is output as a dynamic symbol. */
if (h->dynindx == -1)
{
if (! bfd_elf32_link_record_dynamic_symbol (info, h))
- return false;
+ {
+ ret = false;
+ break;
+ }
}
h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
break;
- case R_SPARC_PC10:
- case R_SPARC_PC22:
+ /* the following relocations don't need to propigate the relocation if
+ linking a shared object since they are section relative. */
+ case R_PPC_SECTOFF:
+ case R_PPC_SECTOFF_LO:
+ case R_PPC_SECTOFF_HI:
+ case R_PPC_SECTOFF_HA:
+ break;
+
+ /* When creating a shared object, we must copy these
+ relocs into the output file. We create a reloc
+ section in dynobj and make room for the reloc. */
+ case R_PPC_REL24:
if (h != NULL
&& strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
break;
- /* Fall through. */
- case R_SPARC_DISP8:
- case R_SPARC_DISP16:
- case R_SPARC_DISP32:
- case R_SPARC_WDISP30:
- case R_SPARC_WDISP22:
+ /* fall through */
+
+ case R_PPC_REL14:
+ case R_PPC_REL14_BRTAKEN:
+ case R_PPC_REL14_BRNTAKEN:
if (h == NULL)
break;
- /* Fall through. */
- case R_SPARC_8:
- case R_SPARC_16:
- case R_SPARC_32:
- case R_SPARC_HI22:
- case R_SPARC_22:
- case R_SPARC_13:
- case R_SPARC_LO10:
- case R_SPARC_UA32:
+ /* fall through */
+
+ default:
if (info->shared
&& (sec->flags & SEC_ALLOC) != 0)
{
- /* When creating a shared object, we must copy these
- relocs into the output file. We create a reloc
- section in dynobj and make room for the reloc. */
if (sreloc == NULL)
{
const char *name;
elf_elfheader (abfd)->e_shstrndx,
elf_section_data (sec)->rel_hdr.sh_name));
if (name == NULL)
- return false;
+ {
+ ret = false;
+ break;
+ }
BFD_ASSERT (strncmp (name, ".rela", 5) == 0
&& strcmp (bfd_get_section_name (abfd, sec),
| SEC_IN_MEMORY
| SEC_READONLY))
|| ! bfd_set_section_alignment (dynobj, sreloc, 2))
- return false;
+ {
+ ret = false;
+ break;
+ }
}
}
}
break;
-#endif
}
}
+ return ret;
+}
+
+\f
+/* Hook called by the linker routine which adds symbols from an object
+ file. We use it to put .comm items in .sbss, and not .bss. */
+
+/*ARGSUSED*/
+static boolean
+ppc_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
+ bfd *abfd;
+ struct bfd_link_info *info;
+ const Elf_Internal_Sym *sym;
+ const char **namep;
+ flagword *flagsp;
+ asection **secp;
+ bfd_vma *valp;
+{
+ if (sym->st_shndx == SHN_COMMON && !info->relocateable && sym->st_size <= bfd_get_gp_size (abfd))
+ {
+ /* Common symbols less than or equal to -G nn bytes are automatically
+ put into .sdata. */
+ elf_linker_section_t *sdata = ppc_elf_create_linker_section (abfd, info, LINKER_SECTION_SDATA);
+ if (!sdata->bss_section)
+ {
+ sdata->bss_section = bfd_make_section (elf_hash_table (info)->dynobj, sdata->bss_name);
+ sdata->bss_section->flags = (sdata->bss_section->flags & ~SEC_LOAD) | SEC_IS_COMMON;
+ }
+
+ *secp = sdata->bss_section;
+ *valp = sym->st_size;
+ }
+
return true;
}
Elf_Internal_Sym *sym;
{
bfd *dynobj;
- elf_linker_section_t *sdata;
- elf_linker_section_t *sdata2;
#ifdef DEBUG
- fprintf (stderr, "ppc_elf_finish_dynamic_symbol called for %s\n", h->root.root.string);
+ fprintf (stderr, "ppc_elf_finish_dynamic_symbol called for %s", h->root.root.string);
#endif
dynobj = elf_hash_table (info)->dynobj;
BFD_ASSERT (dynobj != NULL);
- sdata = elf_linker_section (dynobj, LINKER_SECTION_SDATA);
- sdata2 = elf_linker_section (dynobj, LINKER_SECTION_SDATA2);
if (h->plt_offset != (bfd_vma) -1)
{
asection *srela;
Elf_Internal_Rela rela;
+#ifdef DEBUG
+ fprintf (stderr, ", plt_offset = %d", h->plt_offset);
+#endif
+
/* This symbol has an entry in the procedure linkage table. Set
it up. */
srela = bfd_get_section_by_name (dynobj, ".rela.plt");
BFD_ASSERT (splt != NULL && srela != NULL);
- /* Fill in the entry in the procedure linkage table. */
-#if 0
- bfd_put_32 (output_bfd,
- 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);
- bfd_put_32 (output_bfd, PLT_ENTRY_WORD2,
- splt->contents + h->plt_offset + 8);
+ /* We don't need to fill in the .plt. The solaris dynamic linker will
+ fill it in. */
/* Fill in the entry in the .rela.plt section. */
rela.r_offset = (splt->output_section->vma
+ splt->output_offset
+ h->plt_offset);
- rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_JMP_SLOT);
+ rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_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));
-#endif
+ + ((h->plt_offset - PLT_INITIAL_ENTRY_SIZE) / 8)));
if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
{
/* This symbols needs a copy reloc. Set it up. */
+#ifdef DEBUG
+ fprintf (stderr, ", copy");
+#endif
+
BFD_ASSERT (h->dynindx != -1);
s = bfd_get_section_by_name (h->root.u.def.section->owner,
++s->reloc_count;
}
+#ifdef DEBUG
+ fprintf (stderr, "\n");
+#endif
+
/* Mark some specially defined symbols as absolute. */
if (strcmp (h->root.root.string, "_DYNAMIC") == 0
|| strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
|| strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
sym->st_shndx = SHN_ABS;
- /* If .sdata is larger than 32767, bump up _SDA_BASE_ by 32768 so that
- we put off getting relocation overflows until it is > 65k. Do the
- same for .sdata2 and _SDA2_BASE_. */
- if (sdata && sdata->sym_hash == h
- && (h->elf_link_hash_flags & ELF_LINK_HASH_DYNAMIC_ADJUSTED) == 0)
- {
- bfd_vma size = 0;
- asection *s = bfd_get_section_by_name (output_bfd, ".sdata");
- if (s)
- size = s->_raw_size;
-
- s = bfd_get_section_by_name (output_bfd, ".sbss");
- if (s)
- size += s->_raw_size;
-
- if (size > 32767)
- h->root.u.def.value += 32768;
-
- h->elf_link_hash_flags |= ELF_LINK_HASH_DYNAMIC_ADJUSTED;
- }
-
- if (sdata2 && sdata2->sym_hash == h
- && (h->elf_link_hash_flags & ELF_LINK_HASH_DYNAMIC_ADJUSTED) == 0)
- {
- bfd_vma size = 0;
- asection *s = bfd_get_section_by_name (output_bfd, ".sdata2");
- if (s)
- size = s->_raw_size;
-
- s = bfd_get_section_by_name (output_bfd, ".sbss2");
- if (s)
- size += s->_raw_size;
-
- if (size > 32767)
- h->root.u.def.value += 32768;
-
- h->elf_link_hash_flags |= ELF_LINK_HASH_DYNAMIC_ADJUSTED;
- }
-
return true;
}
switch (dyn.d_tag)
{
- case DT_PLTGOT: name = ".plt"; size = false; break;
- case DT_PLTRELSZ: name = ".rela.plt"; size = true; break;
+ case DT_PLTGOT: name = ".plt"; size = false; break;
+ case DT_PLTRELSZ: name = ".rela.plt"; size = true; break;
case DT_JMPREL: name = ".rela.plt"; size = false; break;
- default: name = NULL; size = false; break;
+ default: name = NULL; size = false; break;
}
if (name != NULL)
Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
bfd *dynobj = elf_hash_table (info)->dynobj;
- elf_linker_section_t *got = elf_linker_section (dynobj, LINKER_SECTION_GOT);
- elf_linker_section_t *sdata = elf_linker_section (dynobj, LINKER_SECTION_SDATA);
- elf_linker_section_t *sdata2 = elf_linker_section (dynobj, LINKER_SECTION_SDATA2);
+ elf_linker_section_t *got = (dynobj) ? elf_linker_section (dynobj, LINKER_SECTION_GOT) : NULL;
+ elf_linker_section_t *sdata = (dynobj) ? elf_linker_section (dynobj, LINKER_SECTION_SDATA) : NULL;
+ elf_linker_section_t *sdata2 = (dynobj) ? elf_linker_section (dynobj, LINKER_SECTION_SDATA2) : NULL;
Elf_Internal_Rela *rel = relocs;
Elf_Internal_Rela *relend = relocs + input_section->reloc_count;
boolean ret = true;
Elf_Internal_Sym *sym = (Elf_Internal_Sym *)0;
asection *sec = (asection *)0;
struct elf_link_hash_entry *h = (struct elf_link_hash_entry *)0;
+ const char *sym_name = (const char *)0;
reloc_howto_type *howto;
unsigned long r_symndx;
bfd_vma relocation;
{
sym = local_syms + r_symndx;
sec = local_sections[r_symndx];
+ sym_name = "<local symbol>";
+
relocation = (sec->output_section->vma
+ sec->output_offset
+ sym->st_value);
else
{
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
+ while (h->root.type == bfd_link_hash_indirect
+ || h->root.type == bfd_link_hash_warning)
+ h = (struct elf_link_hash_entry *) h->root.u.i.link;
+ sym_name = h->root.root.string;
if (h->root.type == bfd_link_hash_defined
|| h->root.type == bfd_link_hash_defweak)
{
sec = h->root.u.def.section;
- relocation = (h->root.u.def.value
- + sec->output_section->vma
- + sec->output_offset);
+ if (!sec || !sec->output_section)
+ {
+ (*_bfd_error_handler) ("%s: Section in shared library for symbol %s\n",
+ bfd_get_filename (input_bfd),
+ sym_name);
+ relocation = 0;
+ }
+ else
+ relocation = (h->root.u.def.value
+ + sec->output_section->vma
+ + sec->output_offset);
}
else if (h->root.type == bfd_link_hash_undefweak)
relocation = 0;
switch ((int)r_type)
{
default:
- (*_bfd_error_handler) ("%s: unknown relocation type %d",
+ (*_bfd_error_handler) ("%s: unknown relocation type %d for symbol %s",
bfd_get_filename (input_bfd),
- (int)r_type);
+ (int)r_type, sym_name);
bfd_set_error (bfd_error_bad_value);
ret = false;
|| strcmp (bfd_get_section_name (abfd, sec), ".got") == 0
|| strcmp (bfd_get_section_name (abfd, sec), ".cgot") == 0)
- addend -= sec->output_section->vma + 0x8000;
+ addend -= sec->output_section->vma + sec->output_offset + 0x8000;
break;
/* arithmetic adjust relocations */
if (strcmp (bfd_get_section_name (abfd, sec), ".sdata") != 0
&& strcmp (bfd_get_section_name (abfd, sec), ".sbss") != 0)
{
- (*_bfd_error_handler) ("%s: The target of a %s relocation is in the wrong section (%s)",
+ (*_bfd_error_handler) ("%s: The target (%s) of a %s relocation is in the wrong section (%s)",
bfd_get_filename (input_bfd),
+ sym_name,
ppc_elf_howto_table[ (int)r_type ]->name,
bfd_get_section_name (abfd, sec));
ret = false;
continue;
}
- relocation = (sdata->sym_hash->root.u.def.value
- + sdata->sym_hash->root.u.def.section->output_section->vma
- - relocation);
+ addend -= (sdata->sym_hash->root.u.def.value
+ + sdata->sym_hash->root.u.def.section->output_section->vma
+ + sdata->sym_hash->root.u.def.section->output_offset);
break;
+
/* relocate against _SDA2_BASE_ */
case (int)R_PPC_EMB_SDA2REL:
BFD_ASSERT (sec != (asection *)0);
if (strcmp (bfd_get_section_name (abfd, sec), ".sdata2") != 0
&& strcmp (bfd_get_section_name (abfd, sec), ".sbss2") != 0)
{
- (*_bfd_error_handler) ("%s: The target of a %s relocation is in the wrong section (%s)",
+ (*_bfd_error_handler) ("%s: The target (%s) of a %s relocation is in the wrong section (%s)",
bfd_get_filename (input_bfd),
+ sym_name,
ppc_elf_howto_table[ (int)r_type ]->name,
bfd_get_section_name (abfd, sec));
ret = false;
continue;
}
- relocation = (sdata2->sym_hash->root.u.def.value
- + sdata2->sym_hash->root.u.def.section->output_section->vma
- - relocation);
+ addend -= (sdata2->sym_hash->root.u.def.value
+ + sdata2->sym_hash->root.u.def.section->output_section->vma
+ + sdata2->sym_hash->root.u.def.section->output_offset);
break;
if (strcmp (name, ".sdata") == 0 || strcmp (name, ".sbss") == 0)
{
reg = 13;
- relocation = (sdata->sym_hash->root.u.def.value
- + sdata->sym_hash->root.u.def.section->output_section->vma
- - relocation);
+ addend -= (sdata->sym_hash->root.u.def.value
+ + sdata->sym_hash->root.u.def.section->output_section->vma
+ + sdata->sym_hash->root.u.def.section->output_offset);
}
else if (strcmp (name, ".sdata2") == 0 || strcmp (name, ".sbss2") == 0)
{
reg = 2;
- relocation = (sdata2->sym_hash->root.u.def.value
- + sdata2->sym_hash->root.u.def.section->output_section->vma
- - relocation);
+ addend -= (sdata2->sym_hash->root.u.def.value
+ + sdata2->sym_hash->root.u.def.section->output_section->vma
+ + sdata2->sym_hash->root.u.def.section->output_offset);
}
else if (strcmp (name, ".PPC.EMB.sdata0") == 0 || strcmp (name, ".PPC.EMB.sbss0") == 0)
else
{
- (*_bfd_error_handler) ("%s: The target of a %s relocation is in the wrong section (%s)",
+ (*_bfd_error_handler) ("%s: The target (%s) of a %s relocation is in the wrong section (%s)",
bfd_get_filename (input_bfd),
+ sym_name,
ppc_elf_howto_table[ (int)r_type ]->name,
bfd_get_section_name (abfd, sec));
ret = false;
continue;
}
- goto unsupported;
+
+ if (r_type == R_PPC_EMB_SDA21)
+ { /* fill in register field */
+ insn = bfd_get_32 (output_bfd, contents + offset);
+ insn = (insn & ~RA_REGISTER_MASK) | (reg << RA_REGISTER_SHIFT);
+ bfd_put_32 (output_bfd, insn, contents + offset);
+ }
}
+ break;
+
+ /* Relocate against the beginning of the section */
+ case (int)R_PPC_SECTOFF:
+ case (int)R_PPC_SECTOFF_LO:
+ case (int)R_PPC_SECTOFF_HI:
+ BFD_ASSERT (sec != (asection *)0);
+ addend -= sec->output_section->vma;
+ break;
+
+ case (int)R_PPC_SECTOFF_HA:
+ BFD_ASSERT (sec != (asection *)0);
+ addend -= sec->output_section->vma;
+ addend += ((relocation + addend) & 0x8000) << 1;
+ break;
+
+ /* Negative relocations */
+ case (int)R_PPC_EMB_NADDR32:
+ case (int)R_PPC_EMB_NADDR16:
+ case (int)R_PPC_EMB_NADDR16_LO:
+ case (int)R_PPC_EMB_NADDR16_HI:
+ addend -= 2*relocation;
+ break;
+
+ case (int)R_PPC_EMB_NADDR16_HA:
+ addend -= 2*relocation;
+ addend += ((relocation + addend) & 0x8000) << 1;
+ break;
+
+ /* NOP relocation that prevents garbage collecting linkers from omitting a
+ reference. */
+ case (int)R_PPC_EMB_MRKREF:
+ continue;
case (int)R_PPC_PLTREL24:
case (int)R_PPC_COPY:
case (int)R_PPC_PLT16_LO:
case (int)R_PPC_PLT16_HI:
case (int)R_PPC_PLT16_HA:
- case (int)R_PPC_SECTOFF:
- case (int)R_PPC_SECTOFF_LO:
- case (int)R_PPC_SECTOFF_HI:
- case (int)R_PPC_SECTOFF_HA:
- case (int)R_PPC_EMB_NADDR32:
- case (int)R_PPC_EMB_NADDR16:
- case (int)R_PPC_EMB_NADDR16_LO:
- case (int)R_PPC_EMB_NADDR16_HI:
- case (int)R_PPC_EMB_NADDR16_HA:
- case (int)R_PPC_EMB_MRKREF:
case (int)R_PPC_EMB_RELSEC16:
case (int)R_PPC_EMB_RELST_LO:
case (int)R_PPC_EMB_RELST_HI:
case (int)R_PPC_EMB_RELST_HA:
case (int)R_PPC_EMB_BIT_FLD:
- unsupported:
- (*_bfd_error_handler) ("%s: Relocation %s is not yet supported.",
+ (*_bfd_error_handler) ("%s: Relocation %s is not yet supported for symbol %s.",
bfd_get_filename (input_bfd),
- ppc_elf_howto_table[ (int)r_type ]->name);
+ ppc_elf_howto_table[ (int)r_type ]->name,
+ sym_name);
bfd_set_error (bfd_error_invalid_operation);
ret = false;
#ifdef DEBUG
- fprintf (stderr, "\ttype = %s (%d), symbol index = %ld, offset = %ld, addend = %ld\n",
+ fprintf (stderr, "\ttype = %s (%d), name = %s, symbol index = %ld, offset = %ld, addend = %ld\n",
howto->name,
(int)r_type,
+ sym_name,
r_symndx,
(long)offset,
(long)addend);
#define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
#define elf_backend_check_relocs ppc_elf_check_relocs
#define elf_backend_adjust_dynamic_symbol ppc_elf_adjust_dynamic_symbol
+#define elf_backend_add_symbol_hook ppc_elf_add_symbol_hook
#define elf_backend_size_dynamic_sections ppc_elf_size_dynamic_sections
#define elf_backend_finish_dynamic_symbol ppc_elf_finish_dynamic_symbol
#define elf_backend_finish_dynamic_sections ppc_elf_finish_dynamic_sections
#define elf_backend_fake_sections ppc_elf_fake_sections
+#define elf_backend_additional_program_headers ppc_elf_additional_program_headers
+#define elf_backend_modify_segment_map ppc_elf_modify_segment_map
#include "elf32-target.h"