};
+#define X86_PCREL_TYPE_P(TYPE) ((TYPE) == R_386_PC32)
+
+#define X86_SIZE_TYPE_P(TYPE) ((TYPE) == R_386_SIZE32)
+
#ifdef DEBUG_GEN_RELOC
#define TRACE(str) \
fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
static const bfd_byte elf_i386_eh_frame_lazy_plt[] =
{
-#define PLT_CIE_LENGTH 20
-#define PLT_FDE_LENGTH 36
-#define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
-#define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
0, 0, 0, 0, /* CIE ID */
1, /* CIE version */
#define PLTRESOLVE_RELOCS 2
#define PLT_NON_JUMP_SLOT_RELOCS 2
-/* Architecture-specific backend data for i386. */
-
-struct elf_i386_backend_data
-{
- /* Value used to fill the unused bytes of the first PLT entry. */
- bfd_byte plt0_pad_byte;
-
- /* Target system. */
- enum
- {
- is_normal,
- is_vxworks,
- is_nacl
- } os;
-};
-
-#define get_elf_i386_backend_data(abfd) \
- ((const struct elf_i386_backend_data *) \
- get_elf_backend_data (abfd)->arch_data)
-
/* These are the standard parameters. */
-static const struct elf_i386_backend_data elf_i386_arch_bed =
+static const struct elf_x86_backend_data elf_i386_arch_bed =
{
- 0, /* plt0_pad_byte */
is_normal /* os */
};
#define elf_backend_arch_data &elf_i386_arch_bed
-#define is_i386_elf(bfd) \
- (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
- && elf_tdata (bfd) != NULL \
- && elf_object_id (bfd) == I386_ELF_DATA)
-
/* Return TRUE if the TLS access code sequence support transition
from R_TYPE. */
{
unsigned int new_to_type = to_type;
- if (bfd_link_executable (info)
- && h != NULL
- && h->dynindx == -1
- && (tls_type & GOT_TLS_IE))
+ if (TLS_TRANSITION_IE_TO_LE_P (info, h, tls_type))
new_to_type = R_386_TLS_LE_32;
if (to_type == R_386_TLS_GD
bfd_boolean
elf_i386_convert_load_reloc (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
bfd_byte *contents,
+ unsigned int *r_type_p,
Elf_Internal_Rela *irel,
struct elf_link_hash_entry *h,
bfd_boolean *converted,
unsigned int r_type;
unsigned int r_symndx;
bfd_vma roff = irel->r_offset;
+ bfd_boolean local_ref;
+ struct elf_x86_link_hash_entry *eh;
if (roff < 2)
return TRUE;
htab = elf_x86_hash_table (link_info, I386_ELF_DATA);
is_pic = bfd_link_pic (link_info);
- r_type = ELF32_R_TYPE (irel->r_info);
+ r_type = *r_type_p;
r_symndx = ELF32_R_SYM (irel->r_info);
modrm = bfd_get_8 (abfd, contents + roff - 1);
register. */
to_reloc_32 = !is_pic || baseless;
+ eh = elf_x86_hash_entry (h);
+
/* Try to convert R_386_GOT32X. Get the symbol referred to by the
reloc. */
if (h == NULL)
goto convert_load;
}
+ /* NB: Also set linker_def via SYMBOL_REFERENCES_LOCAL_P. */
+ local_ref = SYMBOL_REFERENCES_LOCAL_P (link_info, h);
+
/* Undefined weak symbol is only bound locally in executable
and its reference is resolved as 0. */
- if (UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info, I386_ELF_DATA, TRUE,
- elf_x86_hash_entry (h)))
+ if (h->root.type == bfd_link_hash_undefweak
+ && !eh->linker_def
+ && local_ref)
{
if (opcode == 0xff)
{
/* We have "call/jmp *foo@GOT[(%reg)]". */
if ((h->root.type == bfd_link_hash_defined
|| h->root.type == bfd_link_hash_defweak)
- && SYMBOL_REFERENCES_LOCAL (link_info, h))
+ && local_ref)
{
/* The function is locally defined. */
convert_branch:
/* Convert R_386_GOT32X to R_386_PC32. */
if (modrm == 0x15 || (modrm & 0xf8) == 0x90)
{
- struct elf_x86_link_hash_entry *eh
- = (struct elf_x86_link_hash_entry *) h;
-
/* Convert to "nop call foo". ADDR_PREFIX_OPCODE
is a nop prefix. */
modrm = 0xe8;
need to adjust addend by -4. */
bfd_put_32 (abfd, -4, contents + irel->r_offset);
irel->r_info = ELF32_R_INFO (r_symndx, R_386_PC32);
-
+ *r_type_p = R_386_PC32;
*converted = TRUE;
}
}
bfd_elf_record_link_assignment. start_stop is set on
__start_SECNAME/__stop_SECNAME which mark section SECNAME. */
if (h->start_stop
+ || eh->linker_def
|| ((h->def_regular
|| h->root.type == bfd_link_hash_defined
|| h->root.type == bfd_link_hash_defweak)
- && SYMBOL_REFERENCES_LOCAL (link_info, h)))
+ && local_ref))
{
convert_load:
if (opcode == 0x8b)
bfd_put_8 (abfd, opcode, contents + roff - 2);
irel->r_info = ELF32_R_INFO (r_symndx, r_type);
-
+ *r_type_p = r_type;
*converted = TRUE;
}
}
/* Rename some of the generic section flags to better document how they
are used here. */
-#define need_convert_load sec_flg0
-#define check_relocs_failed sec_flg1
+#define check_relocs_failed sec_flg0
/* Look through the relocs for a section during the first phase, and
calculate needed space in the global offset table, procedure linkage
const Elf_Internal_Rela *rel_end;
asection *sreloc;
bfd_byte *contents;
+ bfd_boolean converted;
if (bfd_link_relocatable (info))
return TRUE;
if ((sec->flags & SEC_ALLOC) == 0)
return TRUE;
- BFD_ASSERT (is_i386_elf (abfd));
-
htab = elf_x86_hash_table (info, I386_ELF_DATA);
if (htab == NULL)
{
return FALSE;
}
+ BFD_ASSERT (is_x86_elf (abfd, htab));
+
/* Get the section contents. */
if (elf_section_data (sec)->this_hdr.contents != NULL)
contents = elf_section_data (sec)->this_hdr.contents;
symtab_hdr = &elf_symtab_hdr (abfd);
sym_hashes = elf_sym_hashes (abfd);
+ converted = FALSE;
+
sreloc = NULL;
rel_end = relocs + sec->reloc_count;
|= elf_gnu_symbol_ifunc;
}
+ if (r_type == R_386_GOT32X
+ && (h == NULL || h->type != STT_GNU_IFUNC))
+ {
+ Elf_Internal_Rela *irel = (Elf_Internal_Rela *) rel;
+ if (!elf_i386_convert_load_reloc (abfd, symtab_hdr, contents,
+ &r_type, irel, h,
+ &converted, info))
+ goto error_return;
+ }
+
if (! elf_i386_tls_transition (info, abfd, sec, contents,
symtab_hdr, sym_hashes,
&r_type, GOT_UNKNOWN,
switch (r_type)
{
case R_386_TLS_LDM:
- htab->tls_ld_or_ldm_got.refcount += 1;
+ htab->tls_ld_or_ldm_got.refcount = 1;
goto create_got;
case R_386_PLT32:
if (h == NULL)
continue;
- eh->has_got_reloc = 1;
+ eh->zero_undefweak &= 0x2;
h->needs_plt = 1;
h->plt.refcount += 1;
break;
if (h != NULL)
{
- h->got.refcount += 1;
+ h->got.refcount = 1;
old_tls_type = elf_x86_hash_entry (h)->tls_type;
}
else
elf_x86_local_got_tls_type (abfd)
= (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
}
- local_got_refcounts[r_symndx] += 1;
+ local_got_refcounts[r_symndx] = 1;
old_tls_type = elf_x86_local_got_tls_type (abfd) [r_symndx];
}
if (r_type != R_386_TLS_IE)
{
if (eh != NULL)
- eh->has_got_reloc = 1;
+ eh->zero_undefweak &= 0x2;
break;
}
/* Fall through */
case R_386_TLS_LE_32:
case R_386_TLS_LE:
if (eh != NULL)
- eh->has_got_reloc = 1;
+ eh->zero_undefweak &= 0x2;
if (bfd_link_executable (info))
break;
info->flags |= DF_STATIC_TLS;
case R_386_32:
case R_386_PC32:
if (eh != NULL && (sec->flags & SEC_CODE) != 0)
- eh->has_non_got_reloc = 1;
+ eh->zero_undefweak |= 0x2;
do_relocation:
/* We are called after all symbols have been resolved. Only
relocation against STT_GNU_IFUNC symbol must go through
size_reloc = FALSE;
do_size:
- /* If we are creating a shared library, and this is a reloc
- against a global symbol, or a non PC relative reloc
- against a local symbol, then we need to copy the reloc
- into the shared library. However, if we are linking with
- -Bsymbolic, we do not need to copy a reloc against a
- global symbol which is defined in an object we are
- including in the link (i.e., DEF_REGULAR is set). 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). In case of a weak definition,
- DEF_REGULAR may be cleared later by a strong definition in
- a shared library. We account for that possibility below by
- storing information in the relocs_copied field of the hash
- table entry. A similar situation occurs when creating
- shared libraries and symbol visibility changes render the
- symbol local.
-
- If on the other hand, we are creating an executable, we
- may need to keep relocations for symbols satisfied by a
- dynamic library if we manage to avoid copy relocs for the
- symbol.
-
- Generate dynamic pointer relocation against STT_GNU_IFUNC
- symbol in the non-code section. */
- if ((bfd_link_pic (info)
- && (r_type != R_386_PC32
- || (h != NULL
- && (! (bfd_link_pie (info)
- || SYMBOLIC_BIND (info, h))
- || h->root.type == bfd_link_hash_defweak
- || !h->def_regular))))
- || (h != NULL
- && h->type == STT_GNU_IFUNC
- && r_type == R_386_32
- && (sec->flags & SEC_CODE) == 0)
- || (ELIMINATE_COPY_RELOCS
- && !bfd_link_pic (info)
- && h != NULL
- && (h->root.type == bfd_link_hash_defweak
- || !h->def_regular)))
+ if (NEED_DYNAMIC_RELOCATION_P (info, h, sec, r_type,
+ R_386_32))
{
struct elf_dyn_relocs *p;
struct elf_dyn_relocs **head;
default:
break;
}
-
- if (r_type == R_386_GOT32X
- && (h == NULL || h->type != STT_GNU_IFUNC))
- sec->need_convert_load = 1;
}
if (elf_section_data (sec)->this_hdr.contents != contents)
{
- if (!info->keep_memory)
+ if (!converted && !info->keep_memory)
free (contents);
else
{
- /* Cache the section contents for elf_link_input_bfd. */
+ /* Cache the section contents for elf_link_input_bfd if any
+ load is converted or --no-keep-memory isn't used. */
elf_section_data (sec)->this_hdr.contents = contents;
}
}
+ /* Cache relocations if any load is converted. */
+ if (elf_section_data (sec)->relocs != relocs && converted)
+ elf_section_data (sec)->relocs = (Elf_Internal_Rela *) relocs;
+
return TRUE;
error_return:
return FALSE;
}
-/* Allocate space in .plt, .got and associated reloc sections for
- dynamic relocs. */
-
-static bfd_boolean
-elf_i386_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
-{
- struct bfd_link_info *info;
- struct elf_x86_link_hash_table *htab;
- struct elf_x86_link_hash_entry *eh;
- struct elf_dyn_relocs *p;
- unsigned plt_entry_size;
- bfd_boolean resolved_to_zero;
-
- if (h->root.type == bfd_link_hash_indirect)
- return TRUE;
-
- eh = (struct elf_x86_link_hash_entry *) h;
-
- info = (struct bfd_link_info *) inf;
- htab = elf_x86_hash_table (info, I386_ELF_DATA);
- if (htab == NULL)
- return FALSE;
-
- plt_entry_size = htab->plt.plt_entry_size;
-
- resolved_to_zero = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
- I386_ELF_DATA,
- eh->has_got_reloc,
- eh);
-
- /* Clear the reference count of function pointer relocations if
- symbol isn't a normal function. */
- if (h->type != STT_FUNC)
- eh->func_pointer_refcount = 0;
-
- /* We can't use the GOT PLT if pointer equality is needed since
- finish_dynamic_symbol won't clear symbol value and the dynamic
- linker won't update the GOT slot. We will get into an infinite
- loop at run-time. */
- if (htab->plt_got != NULL
- && h->type != STT_GNU_IFUNC
- && !h->pointer_equality_needed
- && h->plt.refcount > 0
- && h->got.refcount > 0)
- {
- /* Don't use the regular PLT if there are both GOT and GOTPLT
- reloctions. */
- h->plt.offset = (bfd_vma) -1;
-
- /* Use the GOT PLT. */
- eh->plt_got.refcount = 1;
- }
-
- /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
- here if it is defined and referenced in a non-shared object. */
- if (h->type == STT_GNU_IFUNC
- && h->def_regular)
- {
- if (_bfd_elf_allocate_ifunc_dyn_relocs (info, h, &eh->dyn_relocs,
- &htab->readonly_dynrelocs_against_ifunc,
- plt_entry_size,
- (htab->plt.has_plt0
- * plt_entry_size),
- 4, TRUE))
- {
- asection *s = htab->plt_second;
- if (h->plt.offset != (bfd_vma) -1 && s != NULL)
- {
- /* Use the second PLT section if it is created. */
- eh->plt_second.offset = s->size;
-
- /* Make room for this entry in the second PLT section. */
- s->size += htab->non_lazy_plt->plt_entry_size;
- }
-
- return TRUE;
- }
- else
- return FALSE;
- }
- /* Don't create the PLT entry if there are only function pointer
- relocations which can be resolved at run-time. */
- else if (htab->elf.dynamic_sections_created
- && (h->plt.refcount > eh->func_pointer_refcount
- || eh->plt_got.refcount > 0))
- {
- bfd_boolean use_plt_got = eh->plt_got.refcount > 0;
-
- /* Clear the reference count of function pointer relocations
- if PLT is used. */
- eh->func_pointer_refcount = 0;
-
- /* Make sure this symbol is output as a dynamic symbol.
- Undefined weak syms won't yet be marked as dynamic. */
- if (h->dynindx == -1
- && !h->forced_local
- && !resolved_to_zero
- && h->root.type == bfd_link_hash_undefweak)
- {
- if (! bfd_elf_link_record_dynamic_symbol (info, h))
- return FALSE;
- }
-
- if (bfd_link_pic (info)
- || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
- {
- asection *s = htab->elf.splt;
- asection *second_s = htab->plt_second;
- asection *got_s = htab->plt_got;
-
- /* If this is the first .plt entry, make room for the special
- first entry. The .plt section is used by prelink to undo
- prelinking for dynamic relocations. */
- if (s->size == 0)
- s->size = htab->plt.has_plt0 * plt_entry_size;
-
- if (use_plt_got)
- eh->plt_got.offset = got_s->size;
- else
- {
- h->plt.offset = s->size;
- if (second_s)
- eh->plt_second.offset = second_s->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 (! bfd_link_pic (info)
- && !h->def_regular)
- {
- if (use_plt_got)
- {
- /* We need to make a call to the entry of the GOT PLT
- instead of regular PLT entry. */
- h->root.u.def.section = got_s;
- h->root.u.def.value = eh->plt_got.offset;
- }
- else
- {
- if (second_s)
- {
- /* We need to make a call to the entry of the
- second PLT instead of regular PLT entry. */
- h->root.u.def.section = second_s;
- h->root.u.def.value = eh->plt_second.offset;
- }
- else
- {
- h->root.u.def.section = s;
- h->root.u.def.value = h->plt.offset;
- }
- }
- }
-
- /* Make room for this entry. */
- if (use_plt_got)
- got_s->size += htab->non_lazy_plt->plt_entry_size;
- else
- {
- s->size += plt_entry_size;
- if (second_s)
- second_s->size += htab->non_lazy_plt->plt_entry_size;
-
- /* We also need to make an entry in the .got.plt section,
- which will be placed in the .got section by the linker
- script. */
- htab->elf.sgotplt->size += 4;
-
- /* There should be no PLT relocation against resolved
- undefined weak symbol in executable. */
- if (!resolved_to_zero)
- {
- /* We also need to make an entry in the .rel.plt
- section. */
- htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
- htab->elf.srelplt->reloc_count++;
- }
- }
-
- if (htab->is_vxworks && !bfd_link_pic (info))
- {
- /* VxWorks has a second set of relocations for each PLT entry
- in executables. They go in a separate relocation section,
- which is processed by the kernel loader. */
-
- /* There are two relocations for the initial PLT entry: an
- R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
- R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
-
- asection *srelplt2 = htab->srelplt2;
- if (h->plt.offset == plt_entry_size)
- srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
-
- /* There are two extra relocations for each subsequent PLT entry:
- an R_386_32 relocation for the GOT entry, and an R_386_32
- relocation for the PLT entry. */
-
- srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
- }
- }
- else
- {
- eh->plt_got.offset = (bfd_vma) -1;
- h->plt.offset = (bfd_vma) -1;
- h->needs_plt = 0;
- }
- }
- else
- {
- eh->plt_got.offset = (bfd_vma) -1;
- h->plt.offset = (bfd_vma) -1;
- h->needs_plt = 0;
- }
-
- eh->tlsdesc_got = (bfd_vma) -1;
-
- /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
- make it a R_386_TLS_LE_32 requiring no TLS entry. */
- if (h->got.refcount > 0
- && bfd_link_executable (info)
- && h->dynindx == -1
- && (elf_x86_hash_entry (h)->tls_type & GOT_TLS_IE))
- h->got.offset = (bfd_vma) -1;
- else if (h->got.refcount > 0)
- {
- asection *s;
- bfd_boolean dyn;
- int tls_type = elf_x86_hash_entry (h)->tls_type;
-
- /* Make sure this symbol is output as a dynamic symbol.
- Undefined weak syms won't yet be marked as dynamic. */
- if (h->dynindx == -1
- && !h->forced_local
- && !resolved_to_zero
- && h->root.type == bfd_link_hash_undefweak)
- {
- if (! bfd_elf_link_record_dynamic_symbol (info, h))
- return FALSE;
- }
-
- s = htab->elf.sgot;
- if (GOT_TLS_GDESC_P (tls_type))
- {
- eh->tlsdesc_got = htab->elf.sgotplt->size
- - elf_x86_compute_jump_table_size (htab);
- htab->elf.sgotplt->size += 8;
- h->got.offset = (bfd_vma) -2;
- }
- if (! GOT_TLS_GDESC_P (tls_type)
- || GOT_TLS_GD_P (tls_type))
- {
- h->got.offset = s->size;
- s->size += 4;
- /* R_386_TLS_GD needs 2 consecutive GOT slots. */
- if (GOT_TLS_GD_P (tls_type) || tls_type == GOT_TLS_IE_BOTH)
- s->size += 4;
- }
- dyn = htab->elf.dynamic_sections_created;
- /* R_386_TLS_IE_32 needs one dynamic relocation,
- R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
- (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
- need two), R_386_TLS_GD needs one if local symbol and two if
- global. No dynamic relocation against resolved undefined weak
- symbol in executable. */
- if (tls_type == GOT_TLS_IE_BOTH)
- htab->elf.srelgot->size += 2 * sizeof (Elf32_External_Rel);
- else if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
- || (tls_type & GOT_TLS_IE))
- htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
- else if (GOT_TLS_GD_P (tls_type))
- htab->elf.srelgot->size += 2 * sizeof (Elf32_External_Rel);
- else if (! GOT_TLS_GDESC_P (tls_type)
- && ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
- && !resolved_to_zero)
- || h->root.type != bfd_link_hash_undefweak)
- && (bfd_link_pic (info)
- || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
- htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
- if (GOT_TLS_GDESC_P (tls_type))
- htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
- }
- else
- h->got.offset = (bfd_vma) -1;
-
- if (eh->dyn_relocs == NULL)
- return TRUE;
-
- /* In the shared -Bsymbolic case, discard space allocated for
- dynamic pc-relative relocs against symbols which turn out to be
- defined in regular objects. For the normal shared case, discard
- space for pc-relative relocs that have become local due to symbol
- visibility changes. */
-
- if (bfd_link_pic (info))
- {
- /* The only reloc that uses pc_count is R_386_PC32, which will
- appear on a call or on something like ".long foo - .". We
- want calls to protected symbols to resolve directly to the
- function rather than going via the plt. If people want
- function pointer comparisons to work as expected then they
- should avoid writing assembly like ".long foo - .". */
- if (SYMBOL_CALLS_LOCAL (info, h))
- {
- struct elf_dyn_relocs **pp;
-
- for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
- {
- p->count -= p->pc_count;
- p->pc_count = 0;
- if (p->count == 0)
- *pp = p->next;
- else
- pp = &p->next;
- }
- }
-
- if (htab->is_vxworks)
- {
- struct elf_dyn_relocs **pp;
- for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
- {
- if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
- *pp = p->next;
- else
- pp = &p->next;
- }
- }
-
- /* Also discard relocs on undefined weak syms with non-default
- visibility or in PIE. */
- if (eh->dyn_relocs != NULL
- && h->root.type == bfd_link_hash_undefweak)
- {
- /* Undefined weak symbol is never bound locally in shared
- library. */
- if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
- || resolved_to_zero)
- {
- if (h->non_got_ref)
- {
- /* Keep dynamic non-GOT/non-PLT relocation so that we
- can branch to 0 without PLT. */
- struct elf_dyn_relocs **pp;
-
- for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
- if (p->pc_count == 0)
- *pp = p->next;
- else
- {
- /* Remove non-R_386_PC32 relocation. */
- p->count = p->pc_count;
- pp = &p->next;
- }
-
- if (eh->dyn_relocs != NULL)
- {
- /* Make sure undefined weak symbols are output
- as dynamic symbols in PIEs for dynamic non-GOT
- non-PLT reloations. */
- if (! bfd_elf_link_record_dynamic_symbol (info, h))
- return FALSE;
- }
- }
- else
- eh->dyn_relocs = NULL;
- }
- else if (h->dynindx == -1
- && !h->forced_local)
- {
- if (! bfd_elf_link_record_dynamic_symbol (info, h))
- return FALSE;
- }
- }
- }
- else if (ELIMINATE_COPY_RELOCS)
- {
- /* For the non-shared case, discard space for relocs against
- symbols which turn out to need copy relocs or are not
- dynamic. Keep dynamic relocations for run-time function
- pointer initialization. */
-
- if ((!h->non_got_ref
- || eh->func_pointer_refcount > 0
- || (h->root.type == bfd_link_hash_undefweak
- && !resolved_to_zero))
- && ((h->def_dynamic
- && !h->def_regular)
- || (htab->elf.dynamic_sections_created
- && (h->root.type == bfd_link_hash_undefweak
- || h->root.type == bfd_link_hash_undefined))))
- {
- /* Make sure this symbol is output as a dynamic symbol.
- Undefined weak syms won't yet be marked as dynamic. */
- if (h->dynindx == -1
- && !h->forced_local
- && !resolved_to_zero
- && h->root.type == bfd_link_hash_undefweak)
- {
- if (! bfd_elf_link_record_dynamic_symbol (info, h))
- return FALSE;
- }
-
- /* If that succeeded, we know we'll be keeping all the
- relocs. */
- if (h->dynindx != -1)
- goto keep;
- }
-
- eh->dyn_relocs = NULL;
- eh->func_pointer_refcount = 0;
-
- keep: ;
- }
-
- /* Finally, allocate space. */
- for (p = eh->dyn_relocs; p != NULL; p = p->next)
- {
- asection *sreloc;
-
- sreloc = elf_section_data (p->sec)->sreloc;
-
- BFD_ASSERT (sreloc != NULL);
- sreloc->size += p->count * sizeof (Elf32_External_Rel);
- }
-
- return TRUE;
-}
-
-/* Allocate space in .plt, .got and associated reloc sections for
- local dynamic relocs. */
-
-static bfd_boolean
-elf_i386_allocate_local_dynrelocs (void **slot, void *inf)
-{
- struct elf_link_hash_entry *h
- = (struct elf_link_hash_entry *) *slot;
-
- if (h->type != STT_GNU_IFUNC
- || !h->def_regular
- || !h->ref_regular
- || !h->forced_local
- || h->root.type != bfd_link_hash_defined)
- abort ();
-
- return elf_i386_allocate_dynrelocs (h, inf);
-}
-
-/* Convert load via the GOT slot to load immediate. */
-
-static bfd_boolean
-elf_i386_convert_load (bfd *abfd, asection *sec,
- struct bfd_link_info *link_info)
-{
- struct elf_x86_link_hash_table *htab;
- Elf_Internal_Shdr *symtab_hdr;
- Elf_Internal_Rela *internal_relocs;
- Elf_Internal_Rela *irel, *irelend;
- bfd_byte *contents;
- bfd_boolean changed;
- bfd_signed_vma *local_got_refcounts;
-
- /* Don't even try to convert non-ELF outputs. */
- if (!is_elf_hash_table (link_info->hash))
- return FALSE;
-
- /* Nothing to do if there is no need or no output. */
- if ((sec->flags & (SEC_CODE | SEC_RELOC)) != (SEC_CODE | SEC_RELOC)
- || sec->need_convert_load == 0
- || bfd_is_abs_section (sec->output_section))
- return TRUE;
-
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
-
- /* Load the relocations for this section. */
- internal_relocs = (_bfd_elf_link_read_relocs
- (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
- link_info->keep_memory));
- if (internal_relocs == NULL)
- return FALSE;
-
- changed = FALSE;
- htab = elf_x86_hash_table (link_info, I386_ELF_DATA);
- local_got_refcounts = elf_local_got_refcounts (abfd);
-
- /* Get the section contents. */
- if (elf_section_data (sec)->this_hdr.contents != NULL)
- contents = elf_section_data (sec)->this_hdr.contents;
- else
- {
- if (!bfd_malloc_and_get_section (abfd, sec, &contents))
- goto error_return;
- }
-
- irelend = internal_relocs + sec->reloc_count;
- for (irel = internal_relocs; irel < irelend; irel++)
- {
- unsigned int r_type = ELF32_R_TYPE (irel->r_info);
- unsigned int r_symndx;
- struct elf_link_hash_entry *h;
- bfd_boolean converted;
-
- /* Don't convert R_386_GOT32 since we can't tell if it is applied
- to "mov $foo@GOT, %reg" which isn't a load via GOT. */
- if (r_type != R_386_GOT32X)
- continue;
-
- r_symndx = ELF32_R_SYM (irel->r_info);
- if (r_symndx < symtab_hdr->sh_info)
- h = _bfd_elf_x86_get_local_sym_hash (htab, sec->owner,
- (const Elf_Internal_Rela *) irel,
- FALSE);
- else
- {
- h = elf_sym_hashes (abfd)[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;
- }
-
- /* STT_GNU_IFUNC must keep GOT32 relocations. */
- if (h != NULL && h->type == STT_GNU_IFUNC)
- continue;
-
- converted = FALSE;
- if (!elf_i386_convert_load_reloc (abfd, symtab_hdr, contents,
- irel, h, &converted, link_info))
- goto error_return;
-
- if (converted)
- {
- changed = converted;
- if (h)
- {
- if (h->got.refcount > 0)
- h->got.refcount -= 1;
- }
- else
- {
- if (local_got_refcounts != NULL
- && local_got_refcounts[r_symndx] > 0)
- local_got_refcounts[r_symndx] -= 1;
- }
- }
- }
-
- if (contents != NULL
- && elf_section_data (sec)->this_hdr.contents != contents)
- {
- if (!changed && !link_info->keep_memory)
- free (contents);
- else
- {
- /* Cache the section contents for elf_link_input_bfd. */
- elf_section_data (sec)->this_hdr.contents = contents;
- }
- }
-
- if (elf_section_data (sec)->relocs != internal_relocs)
- {
- if (!changed)
- free (internal_relocs);
- else
- elf_section_data (sec)->relocs = internal_relocs;
- }
-
- return TRUE;
-
- error_return:
- if (contents != NULL
- && elf_section_data (sec)->this_hdr.contents != contents)
- free (contents);
- if (internal_relocs != NULL
- && elf_section_data (sec)->relocs != internal_relocs)
- free (internal_relocs);
- return FALSE;
-}
-
-/* Set the sizes of the dynamic sections. */
-
-static bfd_boolean
-elf_i386_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
-{
- struct elf_x86_link_hash_table *htab;
- bfd *dynobj;
- asection *s;
- bfd_boolean relocs;
- bfd *ibfd;
-
- htab = elf_x86_hash_table (info, I386_ELF_DATA);
- if (htab == NULL)
- return FALSE;
- dynobj = htab->elf.dynobj;
- if (dynobj == NULL)
- abort ();
-
- /* Set up .got offsets for local syms, and space for local dynamic
- relocs. */
- for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
- {
- bfd_signed_vma *local_got;
- bfd_signed_vma *end_local_got;
- char *local_tls_type;
- bfd_vma *local_tlsdesc_gotent;
- bfd_size_type locsymcount;
- Elf_Internal_Shdr *symtab_hdr;
- asection *srel;
-
- if (! is_i386_elf (ibfd))
- continue;
-
- for (s = ibfd->sections; s != NULL; s = s->next)
- {
- struct elf_dyn_relocs *p;
-
- if (!elf_i386_convert_load (ibfd, s, info))
- return FALSE;
-
- for (p = ((struct elf_dyn_relocs *)
- elf_section_data (s)->local_dynrel);
- p != NULL;
- p = p->next)
- {
- if (!bfd_is_abs_section (p->sec)
- && bfd_is_abs_section (p->sec->output_section))
- {
- /* Input section has been discarded, either because
- it is a copy of a linkonce section or due to
- linker script /DISCARD/, so we'll be discarding
- the relocs too. */
- }
- else if (htab->is_vxworks
- && strcmp (p->sec->output_section->name,
- ".tls_vars") == 0)
- {
- /* Relocations in vxworks .tls_vars sections are
- handled specially by the loader. */
- }
- else if (p->count != 0)
- {
- srel = elf_section_data (p->sec)->sreloc;
- srel->size += p->count * sizeof (Elf32_External_Rel);
- if ((p->sec->output_section->flags & SEC_READONLY) != 0
- && (info->flags & DF_TEXTREL) == 0)
- {
- info->flags |= DF_TEXTREL;
- if ((info->warn_shared_textrel && bfd_link_pic (info))
- || info->error_textrel)
- /* xgettext:c-format */
- info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
- p->sec->owner, p->sec);
- }
- }
- }
- }
-
- local_got = elf_local_got_refcounts (ibfd);
- if (!local_got)
- continue;
-
- symtab_hdr = &elf_symtab_hdr (ibfd);
- locsymcount = symtab_hdr->sh_info;
- end_local_got = local_got + locsymcount;
- local_tls_type = elf_x86_local_got_tls_type (ibfd);
- local_tlsdesc_gotent = elf_x86_local_tlsdesc_gotent (ibfd);
- s = htab->elf.sgot;
- srel = htab->elf.srelgot;
- for (; local_got < end_local_got;
- ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
- {
- *local_tlsdesc_gotent = (bfd_vma) -1;
- if (*local_got > 0)
- {
- if (GOT_TLS_GDESC_P (*local_tls_type))
- {
- *local_tlsdesc_gotent = htab->elf.sgotplt->size
- - elf_x86_compute_jump_table_size (htab);
- htab->elf.sgotplt->size += 8;
- *local_got = (bfd_vma) -2;
- }
- if (! GOT_TLS_GDESC_P (*local_tls_type)
- || GOT_TLS_GD_P (*local_tls_type))
- {
- *local_got = s->size;
- s->size += 4;
- if (GOT_TLS_GD_P (*local_tls_type)
- || *local_tls_type == GOT_TLS_IE_BOTH)
- s->size += 4;
- }
- if (bfd_link_pic (info)
- || GOT_TLS_GD_ANY_P (*local_tls_type)
- || (*local_tls_type & GOT_TLS_IE))
- {
- if (*local_tls_type == GOT_TLS_IE_BOTH)
- srel->size += 2 * sizeof (Elf32_External_Rel);
- else if (GOT_TLS_GD_P (*local_tls_type)
- || ! GOT_TLS_GDESC_P (*local_tls_type))
- srel->size += sizeof (Elf32_External_Rel);
- if (GOT_TLS_GDESC_P (*local_tls_type))
- htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
- }
- }
- else
- *local_got = (bfd_vma) -1;
- }
- }
-
- if (htab->tls_ld_or_ldm_got.refcount > 0)
- {
- /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
- relocs. */
- htab->tls_ld_or_ldm_got.offset = htab->elf.sgot->size;
- htab->elf.sgot->size += 8;
- htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
- }
- else
- htab->tls_ld_or_ldm_got.offset = -1;
-
- /* Allocate global sym .plt and .got entries, and space for global
- sym dynamic relocs. */
- elf_link_hash_traverse (&htab->elf, elf_i386_allocate_dynrelocs, info);
-
- /* Allocate .plt and .got entries, and space for local symbols. */
- htab_traverse (htab->loc_hash_table,
- elf_i386_allocate_local_dynrelocs,
- info);
-
- /* For every jump slot reserved in the sgotplt, reloc_count is
- incremented. However, when we reserve space for TLS descriptors,
- it's not incremented, so in order to compute the space reserved
- for them, it suffices to multiply the reloc count by the jump
- slot size.
-
- PR ld/13302: We start next_irelative_index at the end of .rela.plt
- so that R_386_IRELATIVE entries come last. */
- if (htab->elf.srelplt)
- {
- htab->next_tls_desc_index = htab->elf.srelplt->reloc_count;
- htab->sgotplt_jump_table_size = htab->next_tls_desc_index * 4;
- htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
- }
- else if (htab->elf.irelplt)
- htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
-
-
- if (htab->elf.sgotplt)
- {
- /* Don't allocate .got.plt section if there are no GOT nor PLT
- entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */
- if ((htab->elf.hgot == NULL
- || !htab->elf.hgot->ref_regular_nonweak)
- && (htab->elf.sgotplt->size
- == get_elf_backend_data (output_bfd)->got_header_size)
- && (htab->elf.splt == NULL
- || htab->elf.splt->size == 0)
- && (htab->elf.sgot == NULL
- || htab->elf.sgot->size == 0)
- && (htab->elf.iplt == NULL
- || htab->elf.iplt->size == 0)
- && (htab->elf.igotplt == NULL
- || htab->elf.igotplt->size == 0))
- htab->elf.sgotplt->size = 0;
- }
-
- if (_bfd_elf_eh_frame_present (info))
- {
- if (htab->plt_eh_frame != NULL
- && htab->elf.splt != NULL
- && htab->elf.splt->size != 0
- && !bfd_is_abs_section (htab->elf.splt->output_section))
- htab->plt_eh_frame->size = htab->plt.eh_frame_plt_size;
-
- if (htab->plt_got_eh_frame != NULL
- && htab->plt_got != NULL
- && htab->plt_got->size != 0
- && !bfd_is_abs_section (htab->plt_got->output_section))
- htab->plt_got_eh_frame->size
- = htab->non_lazy_plt->eh_frame_plt_size;
-
- /* Unwind info for the second PLT and .plt.got sections are
- identical. */
- if (htab->plt_second_eh_frame != NULL
- && htab->plt_second != NULL
- && htab->plt_second->size != 0
- && !bfd_is_abs_section (htab->plt_second->output_section))
- htab->plt_second_eh_frame->size
- = htab->non_lazy_plt->eh_frame_plt_size;
- }
-
- /* We now have determined the sizes of the various dynamic sections.
- Allocate memory for them. */
- relocs = FALSE;
- for (s = dynobj->sections; s != NULL; s = s->next)
- {
- bfd_boolean strip_section = TRUE;
-
- if ((s->flags & SEC_LINKER_CREATED) == 0)
- continue;
-
- if (s == htab->elf.splt
- || s == htab->elf.sgot)
- {
- /* Strip this section if we don't need it; see the
- comment below. */
- /* We'd like to strip these sections if they aren't needed, but if
- we've exported dynamic symbols from them we must leave them.
- It's too late to tell BFD to get rid of the symbols. */
-
- if (htab->elf.hplt != NULL)
- strip_section = FALSE;
- }
- else if (s == htab->elf.sgotplt
- || s == htab->elf.iplt
- || s == htab->elf.igotplt
- || s == htab->plt_second
- || s == htab->plt_got
- || s == htab->plt_eh_frame
- || s == htab->plt_got_eh_frame
- || s == htab->plt_second_eh_frame
- || s == htab->elf.sdynbss
- || s == htab->elf.sdynrelro)
- {
- /* Strip these too. */
- }
- else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rel"))
- {
- if (s->size != 0
- && s != htab->elf.srelplt
- && s != htab->srelplt2)
- relocs = 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
- {
- /* It's not one of our sections, so don't allocate space. */
- continue;
- }
-
- if (s->size == 0)
- {
- /* If we don't need this section, strip it from the
- output file. This is mostly to handle .rel.bss and
- .rel.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
- function which decides whether anything needs to go
- into these sections. */
- if (strip_section)
- s->flags |= SEC_EXCLUDE;
- continue;
- }
-
- if ((s->flags & SEC_HAS_CONTENTS) == 0)
- continue;
-
- /* Allocate memory for the section contents. We use bfd_zalloc
- here in case unused entries are not reclaimed before the
- section's contents are written out. This should not happen,
- but this way if it does, we get a R_386_NONE reloc instead
- of garbage. */
- s->contents = (unsigned char *) bfd_zalloc (dynobj, s->size);
- if (s->contents == NULL)
- return FALSE;
- }
-
- if (htab->plt_eh_frame != NULL
- && htab->plt_eh_frame->contents != NULL)
- {
- memcpy (htab->plt_eh_frame->contents,
- htab->plt.eh_frame_plt,
- htab->plt_eh_frame->size);
- bfd_put_32 (dynobj, htab->elf.splt->size,
- htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
- }
-
- if (htab->plt_got_eh_frame != NULL
- && htab->plt_got_eh_frame->contents != NULL)
- {
- memcpy (htab->plt_got_eh_frame->contents,
- htab->non_lazy_plt->eh_frame_plt,
- htab->plt_got_eh_frame->size);
- bfd_put_32 (dynobj, htab->plt_got->size,
- (htab->plt_got_eh_frame->contents
- + PLT_FDE_LEN_OFFSET));
- }
-
- if (htab->plt_second_eh_frame != NULL
- && htab->plt_second_eh_frame->contents != NULL)
- {
- memcpy (htab->plt_second_eh_frame->contents,
- htab->non_lazy_plt->eh_frame_plt,
- htab->plt_second_eh_frame->size);
- bfd_put_32 (dynobj, htab->plt_second->size,
- (htab->plt_second_eh_frame->contents
- + PLT_FDE_LEN_OFFSET));
- }
-
- if (htab->elf.dynamic_sections_created)
- {
- /* Add some entries to the .dynamic section. We fill in the
- values later, in elf_i386_finish_dynamic_sections, but we
- must add the entries now so that we get the correct size for
- the .dynamic section. The DT_DEBUG entry is filled in by the
- dynamic linker and used by the debugger. */
-#define add_dynamic_entry(TAG, VAL) \
- _bfd_elf_add_dynamic_entry (info, TAG, VAL)
-
- if (bfd_link_executable (info))
- {
- if (!add_dynamic_entry (DT_DEBUG, 0))
- return FALSE;
- }
-
- if (htab->elf.splt->size != 0)
- {
- /* DT_PLTGOT is used by prelink even if there is no PLT
- relocation. */
- if (!add_dynamic_entry (DT_PLTGOT, 0))
- return FALSE;
- }
-
- if (htab->elf.srelplt->size != 0)
- {
- if (!add_dynamic_entry (DT_PLTRELSZ, 0)
- || !add_dynamic_entry (DT_PLTREL, DT_REL)
- || !add_dynamic_entry (DT_JMPREL, 0))
- return FALSE;
- }
-
- if (relocs)
- {
- if (!add_dynamic_entry (DT_REL, 0)
- || !add_dynamic_entry (DT_RELSZ, 0)
- || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
- return FALSE;
-
- /* If any dynamic relocs apply to a read-only section,
- then we need a DT_TEXTREL entry. */
- if ((info->flags & DF_TEXTREL) == 0)
- elf_link_hash_traverse (&htab->elf,
- _bfd_x86_elf_readonly_dynrelocs,
- info);
-
- if ((info->flags & DF_TEXTREL) != 0)
- {
- if (htab->readonly_dynrelocs_against_ifunc)
- {
- info->callbacks->einfo
- (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
- bfd_set_error (bfd_error_bad_value);
- return FALSE;
- }
-
- if (!add_dynamic_entry (DT_TEXTREL, 0))
- return FALSE;
- }
- }
- if (htab->is_vxworks
- && !elf_vxworks_add_dynamic_entries (output_bfd, info))
- return FALSE;
- }
-#undef add_dynamic_entry
-
- return TRUE;
-}
-
/* Set the correct type for an x86 ELF section. We do this by the
section name, which is a hack, but ought to work. */
bfd_boolean is_vxworks_tls;
unsigned plt_entry_size;
- BFD_ASSERT (is_i386_elf (input_bfd));
-
/* Skip if check_relocs failed. */
if (input_section->check_relocs_failed)
return FALSE;
htab = elf_x86_hash_table (info, I386_ELF_DATA);
if (htab == NULL)
return FALSE;
+
+ BFD_ASSERT (is_x86_elf (input_bfd, htab));
+
symtab_hdr = &elf_symtab_hdr (input_bfd);
sym_hashes = elf_sym_hashes (input_bfd);
local_got_offsets = elf_local_got_offsets (input_bfd);
local_tlsdesc_gotents = elf_x86_local_tlsdesc_gotent (input_bfd);
/* We have to handle relocations in vxworks .tls_vars sections
specially, because the dynamic loader is 'weird'. */
- is_vxworks_tls = (htab->is_vxworks
+ is_vxworks_tls = (htab->target_os == is_vxworks
&& bfd_link_pic (info)
&& !strcmp (input_section->output_section->name,
".tls_vars"));
relend = relocs + input_section->reloc_count;
for (; rel < relend; wrel++, rel++)
{
- unsigned int r_type;
+ unsigned int r_type, r_type_tls;
reloc_howto_type *howto;
unsigned long r_symndx;
struct elf_link_hash_entry *h;
+ input_section->output_offset
+ offset);
- if (h->dynindx == -1
- || h->forced_local
- || bfd_link_executable (info))
+ if (POINTER_LOCAL_IFUNC_P (info, h))
{
info->callbacks->minfo (_("Local IFUNC function `%s' in %B\n"),
h->root.root.string,
}
resolved_to_zero = (eh != NULL
- && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
- I386_ELF_DATA,
- eh->has_got_reloc,
- eh));
+ && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh));
switch (r_type)
{
relative_reloc = FALSE;
if (h != NULL)
{
- bfd_boolean dyn;
-
off = h->got.offset;
- dyn = htab->elf.dynamic_sections_created;
- if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
- bfd_link_pic (info),
- h)
- || (bfd_link_pic (info)
- && SYMBOL_REFERENCES_LOCAL (info, h))
- || (ELF_ST_VISIBILITY (h->other)
- && h->root.type == bfd_link_hash_undefweak))
+ if (RESOLVED_LOCALLY_P (info, h, htab))
{
- /* This is actually a static link, or it is a
- -Bsymbolic link and the symbol is defined
- 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.
+ /* 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 .rel.got
relocation entry to initialize the value. This
htab->elf.sgot->contents + off);
h->got.offset |= 1;
- if (h->dynindx == -1
- && !h->forced_local
- && h->root.type != bfd_link_hash_undefweak
- && bfd_link_pic (info))
+ if (GENERATE_RELATIVE_RELOC_P (info, h))
{
/* PR ld/21402: If this symbol isn't dynamic
in PIC, generate R_386_RELATIVE here. */
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
- else if (!SYMBOL_REFERENCES_LOCAL (info, h)
+ else if (!SYMBOL_REFERENCES_LOCAL_P (info, h)
&& (h->type == STT_FUNC
|| h->type == STT_OBJECT)
&& ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
|| is_vxworks_tls)
break;
- /* Copy dynamic function pointer relocations. Don't generate
- dynamic relocations against resolved undefined weak symbols
- in PIE, except for R_386_PC32. */
- if ((bfd_link_pic (info)
- && (h == NULL
- || ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
- && (!resolved_to_zero
- || r_type == R_386_PC32))
- || h->root.type != bfd_link_hash_undefweak))
- && ((r_type != R_386_PC32 && r_type != R_386_SIZE32)
- || !SYMBOL_CALLS_LOCAL (info, h)))
- || (ELIMINATE_COPY_RELOCS
- && !bfd_link_pic (info)
- && h != NULL
- && h->dynindx != -1
- && (!h->non_got_ref
- || eh->func_pointer_refcount > 0
- || (h->root.type == bfd_link_hash_undefweak
- && !resolved_to_zero))
- && ((h->def_dynamic && !h->def_regular)
- /* Undefined weak symbol is bound locally when
- PIC is false. */
- || h->root.type == bfd_link_hash_undefweak)))
+ if (GENERATE_DYNAMIC_RELOCATION_P (info, eh, r_type,
+ FALSE, resolved_to_zero,
+ (r_type == R_386_PC32)))
{
Elf_Internal_Rela outrel;
bfd_boolean skip, relocate;
if (skip)
memset (&outrel, 0, sizeof outrel);
- else if (h != NULL
- && h->dynindx != -1
- && (r_type == R_386_PC32
- || !(bfd_link_executable (info)
- || SYMBOLIC_BIND (info, h))
- || !h->def_regular))
+ else if (COPY_INPUT_RELOC_P (info, h, r_type))
outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
else
{
if (tls_type == GOT_TLS_IE)
tls_type = GOT_TLS_IE_NEG;
+ r_type_tls = r_type;
if (! elf_i386_tls_transition (info, input_bfd,
input_section, contents,
symtab_hdr, sym_hashes,
- &r_type, tls_type, rel,
+ &r_type_tls, tls_type, rel,
relend, h, r_symndx, TRUE))
return FALSE;
- if (r_type == R_386_TLS_LE_32)
+ if (r_type_tls == R_386_TLS_LE_32)
{
BFD_ASSERT (! unresolved_reloc);
- if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
+ if (r_type == R_386_TLS_GD)
{
unsigned int type;
bfd_vma roff;
wrel++;
continue;
}
- else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
+ else if (r_type == R_386_TLS_GOTDESC)
{
/* GDesc -> LE transition.
It's originally something like:
contents + roff);
continue;
}
- else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
+ else if (r_type == R_386_TLS_DESC_CALL)
{
/* GDesc -> LE transition.
It's originally:
bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
continue;
}
- else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
+ else if (r_type == R_386_TLS_IE)
{
unsigned int val;
}
else
BFD_FAIL ();
- if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTIE)
+ if (r_type == R_386_TLS_GOTIE)
bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
contents + rel->r_offset);
else
if (off >= (bfd_vma) -2
&& ! GOT_TLS_GDESC_P (tls_type))
abort ();
- if (r_type == R_386_TLS_GOTDESC
- || r_type == R_386_TLS_DESC_CALL)
+ if (r_type_tls == R_386_TLS_GOTDESC
+ || r_type_tls == R_386_TLS_DESC_CALL)
{
relocation = htab->sgotplt_jump_table_size + offplt;
unresolved_reloc = FALSE;
}
- else if (r_type == ELF32_R_TYPE (rel->r_info))
+ else if (r_type_tls == r_type)
{
bfd_vma g_o_t = htab->elf.sgotplt->output_section->vma
+ htab->elf.sgotplt->output_offset;
relocation += g_o_t;
unresolved_reloc = FALSE;
}
- else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
+ else if (r_type == R_386_TLS_GD)
{
unsigned int val, type;
bfd_vma roff;
wrel++;
continue;
}
- else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
+ else if (r_type == R_386_TLS_GOTDESC)
{
/* GDesc -> IE transition.
It's originally something like:
contents + roff);
continue;
}
- else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
+ else if (r_type == R_386_TLS_DESC_CALL)
{
/* GDesc -> IE transition.
It's originally:
/* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
resolved undefined weak symbols in executable so that their
references have value 0 at run-time. */
- local_undefweak = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, I386_ELF_DATA,
- eh->has_got_reloc,
- eh);
+ local_undefweak = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh);
if (h->plt.offset != (bfd_vma) -1)
{
relplt = htab->elf.irelplt;
}
- /* This symbol has an entry in the procedure linkage table. Set
- it up. */
-
- if ((h->dynindx == -1
- && !local_undefweak
- && !((h->forced_local || bfd_link_executable (info))
- && h->def_regular
- && h->type == STT_GNU_IFUNC))
- || plt == NULL
- || gotplt == NULL
- || relplt == NULL)
- abort ();
+ VERIFY_PLT_ENTRY (info, h, plt, gotplt, relplt, local_undefweak)
/* Get the index in the procedure linkage table which
corresponds to this symbol. This is the index of this symbol
resolved_plt->contents + plt_offset
+ htab->plt.plt_got_offset);
- if (htab->is_vxworks)
+ if (htab->target_os == is_vxworks)
{
int s, k, reloc_index;
rel.r_offset = (gotplt->output_section->vma
+ gotplt->output_offset
+ got_offset);
- if (h->dynindx == -1
- || ((bfd_link_executable (info)
- || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
- && h->def_regular
- && h->type == STT_GNU_IFUNC))
+ if (PLT_LOCAL_IFUNC_P (info, h))
{
info->callbacks->minfo (_("Local IFUNC function `%s' in %B\n"),
h->root.root.string,
in static executable. */
relgot = htab->elf.irelplt;
}
- if (SYMBOL_REFERENCES_LOCAL (info, h))
+ if (SYMBOL_REFERENCES_LOCAL_P (info, h))
{
info->callbacks->minfo (_("Local IFUNC function `%s' in %B\n"),
h->root.root.string,
}
}
else if (bfd_link_pic (info)
- && SYMBOL_REFERENCES_LOCAL (info, h))
+ && SYMBOL_REFERENCES_LOCAL_P (info, h))
{
BFD_ASSERT((h->got.offset & 1) != 0);
rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
asection *s;
/* This symbol needs a copy reloc. Set it up. */
-
- if (h->dynindx == -1
- || (h->root.type != bfd_link_hash_defined
- && h->root.type != bfd_link_hash_defweak)
- || htab->elf.srelbss == NULL
- || htab->elf.sreldynrelro == NULL)
- abort ();
+ VERIFY_COPY_RELOC (h, htab)
rel.r_offset = (h->root.u.def.value
+ h->root.u.def.section->output_section->vma
struct bfd_link_info *info)
{
struct elf_x86_link_hash_table *htab;
- bfd *dynobj;
- asection *sdyn;
- const struct elf_i386_backend_data *abed;
- htab = elf_x86_hash_table (info, I386_ELF_DATA);
+ htab = _bfd_x86_elf_finish_dynamic_sections (output_bfd, info);
if (htab == NULL)
return FALSE;
- dynobj = htab->elf.dynobj;
- sdyn = bfd_get_linker_section (dynobj, ".dynamic");
- abed = get_elf_i386_backend_data (output_bfd);
+ if (!htab->elf.dynamic_sections_created)
+ return TRUE;
- if (htab->elf.dynamic_sections_created)
+ if (htab->elf.splt && htab->elf.splt->size > 0)
{
- Elf32_External_Dyn *dyncon, *dynconend;
+ /* UnixWare sets the entsize of .plt to 4, although that doesn't
+ really seem like the right value. */
+ elf_section_data (htab->elf.splt->output_section)
+ ->this_hdr.sh_entsize = 4;
- if (sdyn == NULL || htab->elf.sgot == NULL)
- abort ();
-
- dyncon = (Elf32_External_Dyn *) sdyn->contents;
- dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
- for (; dyncon < dynconend; dyncon++)
+ if (htab->plt.has_plt0)
{
- Elf_Internal_Dyn dyn;
- asection *s;
-
- bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
-
- switch (dyn.d_tag)
+ /* Fill in the special first entry in the procedure linkage
+ table. */
+ memcpy (htab->elf.splt->contents, htab->plt.plt0_entry,
+ htab->lazy_plt->plt0_entry_size);
+ memset (htab->elf.splt->contents + htab->lazy_plt->plt0_entry_size,
+ htab->plt0_pad_byte,
+ htab->plt.plt_entry_size - htab->lazy_plt->plt0_entry_size);
+ if (!bfd_link_pic (info))
{
- default:
- if (htab->is_vxworks
- && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
- break;
- continue;
-
- case DT_PLTGOT:
- s = htab->elf.sgotplt;
- dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
- break;
-
- case DT_JMPREL:
- s = htab->elf.srelplt;
- dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
- break;
-
- case DT_PLTRELSZ:
- s = htab->elf.srelplt;
- dyn.d_un.d_val = s->size;
- break;
- }
-
- bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
- }
-
- if (htab->elf.splt && htab->elf.splt->size > 0)
- {
- /* UnixWare sets the entsize of .plt to 4, although that doesn't
- really seem like the right value. */
- elf_section_data (htab->elf.splt->output_section)
- ->this_hdr.sh_entsize = 4;
+ bfd_put_32 (output_bfd,
+ (htab->elf.sgotplt->output_section->vma
+ + htab->elf.sgotplt->output_offset
+ + 4),
+ htab->elf.splt->contents
+ + htab->lazy_plt->plt0_got1_offset);
+ bfd_put_32 (output_bfd,
+ (htab->elf.sgotplt->output_section->vma
+ + htab->elf.sgotplt->output_offset
+ + 8),
+ htab->elf.splt->contents
+ + htab->lazy_plt->plt0_got2_offset);
- if (htab->plt.has_plt0)
- {
- /* Fill in the special first entry in the procedure linkage
- table. */
- memcpy (htab->elf.splt->contents, htab->plt.plt0_entry,
- htab->lazy_plt->plt0_entry_size);
- memset (htab->elf.splt->contents + htab->lazy_plt->plt0_entry_size,
- abed->plt0_pad_byte,
- htab->plt.plt_entry_size - htab->lazy_plt->plt0_entry_size);
- if (!bfd_link_pic (info))
+ if (htab->target_os == is_vxworks)
{
- bfd_put_32 (output_bfd,
- (htab->elf.sgotplt->output_section->vma
- + htab->elf.sgotplt->output_offset
- + 4),
- htab->elf.splt->contents
- + htab->lazy_plt->plt0_got1_offset);
- bfd_put_32 (output_bfd,
- (htab->elf.sgotplt->output_section->vma
- + htab->elf.sgotplt->output_offset
- + 8),
- htab->elf.splt->contents
- + htab->lazy_plt->plt0_got2_offset);
+ Elf_Internal_Rela rel;
+ int num_plts = (htab->elf.splt->size
+ / htab->plt.plt_entry_size) - 1;
+ unsigned char *p;
+ asection *srelplt2 = htab->srelplt2;
+
+ /* Generate a relocation for _GLOBAL_OFFSET_TABLE_
+ + 4. On IA32 we use REL relocations so the
+ addend goes in the PLT directly. */
+ rel.r_offset = (htab->elf.splt->output_section->vma
+ + htab->elf.splt->output_offset
+ + htab->lazy_plt->plt0_got1_offset);
+ rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx,
+ R_386_32);
+ bfd_elf32_swap_reloc_out (output_bfd, &rel,
+ srelplt2->contents);
+ /* Generate a relocation for _GLOBAL_OFFSET_TABLE_
+ + 8. */
+ rel.r_offset = (htab->elf.splt->output_section->vma
+ + htab->elf.splt->output_offset
+ + htab->lazy_plt->plt0_got2_offset);
+ rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx,
+ R_386_32);
+ bfd_elf32_swap_reloc_out (output_bfd, &rel,
+ srelplt2->contents +
+ sizeof (Elf32_External_Rel));
+ /* Correct the .rel.plt.unloaded relocations. */
+ p = srelplt2->contents;
+ if (bfd_link_pic (info))
+ p += PLTRESOLVE_RELOCS_SHLIB * sizeof (Elf32_External_Rel);
+ else
+ p += PLTRESOLVE_RELOCS * sizeof (Elf32_External_Rel);
- if (htab->is_vxworks)
+ for (; num_plts; num_plts--)
{
- Elf_Internal_Rela rel;
- int num_plts = (htab->elf.splt->size
- / htab->plt.plt_entry_size) - 1;
- unsigned char *p;
- asection *srelplt2 = htab->srelplt2;
-
- /* Generate a relocation for _GLOBAL_OFFSET_TABLE_
- + 4. On IA32 we use REL relocations so the
- addend goes in the PLT directly. */
- rel.r_offset = (htab->elf.splt->output_section->vma
- + htab->elf.splt->output_offset
- + htab->lazy_plt->plt0_got1_offset);
- rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx,
- R_386_32);
- bfd_elf32_swap_reloc_out (output_bfd, &rel,
- srelplt2->contents);
- /* Generate a relocation for _GLOBAL_OFFSET_TABLE_
- + 8. */
- rel.r_offset = (htab->elf.splt->output_section->vma
- + htab->elf.splt->output_offset
- + htab->lazy_plt->plt0_got2_offset);
+ bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx,
R_386_32);
- bfd_elf32_swap_reloc_out (output_bfd, &rel,
- srelplt2->contents +
- sizeof (Elf32_External_Rel));
- /* Correct the .rel.plt.unloaded relocations. */
- p = srelplt2->contents;
- if (bfd_link_pic (info))
- p += PLTRESOLVE_RELOCS_SHLIB * sizeof (Elf32_External_Rel);
- else
- p += PLTRESOLVE_RELOCS * sizeof (Elf32_External_Rel);
+ bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
+ p += sizeof (Elf32_External_Rel);
- for (; num_plts; num_plts--)
- {
- bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
- rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx,
- R_386_32);
- bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
- p += sizeof (Elf32_External_Rel);
-
- bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
- rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx,
- R_386_32);
- bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
- p += sizeof (Elf32_External_Rel);
- }
+ bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
+ rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx,
+ R_386_32);
+ bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
+ p += sizeof (Elf32_External_Rel);
}
}
}
}
-
- if (htab->plt_got != NULL && htab->plt_got->size > 0)
- elf_section_data (htab->plt_got->output_section)
- ->this_hdr.sh_entsize = htab->non_lazy_plt->plt_entry_size;
-
- if (htab->plt_second != NULL && htab->plt_second->size > 0)
- elf_section_data (htab->plt_second->output_section)
- ->this_hdr.sh_entsize = htab->non_lazy_plt->plt_entry_size;
}
- /* Fill in the first three entries in the global offset table. */
- if (htab->elf.sgotplt && htab->elf.sgotplt->size > 0)
- {
- if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
- {
- _bfd_error_handler
- (_("discarded output section: `%A'"), htab->elf.sgotplt);
- return FALSE;
- }
-
- bfd_put_32 (output_bfd,
- (sdyn == NULL ? 0
- : sdyn->output_section->vma + sdyn->output_offset),
- htab->elf.sgotplt->contents);
- bfd_put_32 (output_bfd, 0, htab->elf.sgotplt->contents + 4);
- bfd_put_32 (output_bfd, 0, htab->elf.sgotplt->contents + 8);
-
- elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize = 4;
- }
-
- /* Adjust .eh_frame for .plt section. */
- if (htab->plt_eh_frame != NULL
- && htab->plt_eh_frame->contents != NULL)
- {
- if (htab->elf.splt != NULL
- && htab->elf.splt->size != 0
- && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
- && htab->elf.splt->output_section != NULL
- && htab->plt_eh_frame->output_section != NULL)
- {
- bfd_vma plt_start = htab->elf.splt->output_section->vma;
- bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
- + htab->plt_eh_frame->output_offset
- + PLT_FDE_START_OFFSET;
- bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
- htab->plt_eh_frame->contents
- + PLT_FDE_START_OFFSET);
- }
- if (htab->plt_eh_frame->sec_info_type
- == SEC_INFO_TYPE_EH_FRAME)
- {
- if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
- htab->plt_eh_frame,
- htab->plt_eh_frame->contents))
- return FALSE;
- }
- }
-
- /* Adjust .eh_frame for .plt.got section. */
- if (htab->plt_got_eh_frame != NULL
- && htab->plt_got_eh_frame->contents != NULL)
- {
- if (htab->plt_got != NULL
- && htab->plt_got->size != 0
- && (htab->plt_got->flags & SEC_EXCLUDE) == 0
- && htab->plt_got->output_section != NULL
- && htab->plt_got_eh_frame->output_section != NULL)
- {
- bfd_vma plt_start = htab->plt_got->output_section->vma;
- bfd_vma eh_frame_start = htab->plt_got_eh_frame->output_section->vma
- + htab->plt_got_eh_frame->output_offset
- + PLT_FDE_START_OFFSET;
- bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
- htab->plt_got_eh_frame->contents
- + PLT_FDE_START_OFFSET);
- }
- if (htab->plt_got_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
- {
- if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
- htab->plt_got_eh_frame,
- htab->plt_got_eh_frame->contents))
- return FALSE;
- }
- }
-
- /* Adjust .eh_frame for the second PLT section. */
- if (htab->plt_second_eh_frame != NULL
- && htab->plt_second_eh_frame->contents != NULL)
- {
- if (htab->plt_second != NULL
- && htab->plt_second->size != 0
- && (htab->plt_second->flags & SEC_EXCLUDE) == 0
- && htab->plt_second->output_section != NULL
- && htab->plt_second_eh_frame->output_section != NULL)
- {
- bfd_vma plt_start = htab->plt_second->output_section->vma;
- bfd_vma eh_frame_start
- = (htab->plt_second_eh_frame->output_section->vma
- + htab->plt_second_eh_frame->output_offset
- + PLT_FDE_START_OFFSET);
- bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
- htab->plt_second_eh_frame->contents
- + PLT_FDE_START_OFFSET);
- }
- if (htab->plt_second_eh_frame->sec_info_type
- == SEC_INFO_TYPE_EH_FRAME)
- {
- if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
- htab->plt_second_eh_frame,
- htab->plt_second_eh_frame->contents))
- return FALSE;
- }
- }
-
- if (htab->elf.sgot && htab->elf.sgot->size > 0)
- elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 4;
-
/* Fill PLT entries for undefined weak symbols in PIE. */
if (bfd_link_pie (info))
bfd_hash_traverse (&info->hash->table,
lazy_plt = NULL;
non_lazy_ibt_plt = NULL;
lazy_ibt_plt = NULL;
- switch (get_elf_i386_backend_data (abfd)->os)
+ switch (get_elf_x86_backend_data (abfd)->target_os)
{
case is_normal:
non_lazy_plt = &elf_i386_non_lazy_plt;
static bfd *
elf_i386_link_setup_gnu_properties (struct bfd_link_info *info)
{
- struct elf_x86_plt_layout_table plt_layout;
+ struct elf_x86_init_table init_table;
- plt_layout.normal_target = FALSE;
- plt_layout.is_vxworks = FALSE;
- switch (get_elf_i386_backend_data (info->output_bfd)->os)
+ switch (get_elf_x86_backend_data (info->output_bfd)->target_os)
{
case is_normal:
- plt_layout.lazy_plt = &elf_i386_lazy_plt;
- plt_layout.non_lazy_plt = &elf_i386_non_lazy_plt;
- plt_layout.lazy_ibt_plt = &elf_i386_lazy_ibt_plt;
- plt_layout.non_lazy_ibt_plt = &elf_i386_non_lazy_ibt_plt;
- plt_layout.normal_target = TRUE;
+ init_table.plt0_pad_byte = 0x0;
+ init_table.lazy_plt = &elf_i386_lazy_plt;
+ init_table.non_lazy_plt = &elf_i386_non_lazy_plt;
+ init_table.lazy_ibt_plt = &elf_i386_lazy_ibt_plt;
+ init_table.non_lazy_ibt_plt = &elf_i386_non_lazy_ibt_plt;
break;
case is_vxworks:
- plt_layout.lazy_plt = &elf_i386_lazy_plt;
- plt_layout.non_lazy_plt = NULL;
- plt_layout.lazy_ibt_plt = NULL;
- plt_layout.non_lazy_ibt_plt = NULL;
- plt_layout.is_vxworks = TRUE;
+ init_table.plt0_pad_byte = 0x90;
+ init_table.lazy_plt = &elf_i386_lazy_plt;
+ init_table.non_lazy_plt = NULL;
+ init_table.lazy_ibt_plt = NULL;
+ init_table.non_lazy_ibt_plt = NULL;
break;
case is_nacl:
- plt_layout.lazy_plt = &elf_i386_nacl_plt;
- plt_layout.non_lazy_plt = NULL;
- plt_layout.lazy_ibt_plt = NULL;
- plt_layout.non_lazy_ibt_plt = NULL;
+ init_table.plt0_pad_byte = 0x90;
+ init_table.lazy_plt = &elf_i386_nacl_plt;
+ init_table.non_lazy_plt = NULL;
+ init_table.lazy_ibt_plt = NULL;
+ init_table.non_lazy_ibt_plt = NULL;
break;
}
- return _bfd_x86_elf_link_setup_gnu_properties (info, &plt_layout);
+ init_table.r_info = elf32_r_info;
+ init_table.r_sym = elf32_r_sym;
+
+ return _bfd_x86_elf_link_setup_gnu_properties (info, &init_table);
}
#define TARGET_LITTLE_SYM i386_elf32_vec
#define elf_backend_grok_psinfo elf_i386_grok_psinfo
#define elf_backend_reloc_type_class elf_i386_reloc_type_class
#define elf_backend_relocate_section elf_i386_relocate_section
-#define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
#define elf_backend_setup_gnu_properties elf_i386_link_setup_gnu_properties
+#define elf_backend_hide_symbol _bfd_x86_elf_hide_symbol
+
+#define elf_backend_linux_prpsinfo32_ugid16 TRUE
#include "elf32-target.h"
|| PLT_FDE_LENGTH != 36 \
|| PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
|| PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
-# error "Need elf_i386_backend_data parameters for eh_frame_plt offsets!"
+# error "Need elf_x86_backend_data parameters for eh_frame_plt offsets!"
#endif
PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
0, 0, 0, 0, /* CIE ID */
sizeof (elf_i386_nacl_eh_frame_plt) /* eh_frame_plt_size */
};
-static const struct elf_i386_backend_data elf_i386_nacl_arch_bed =
+static const struct elf_x86_backend_data elf_i386_nacl_arch_bed =
{
- 0x90, /* plt0_pad_byte: nop insn */
is_nacl /* os */
};
#undef elf_backend_plt_alignment
#define elf_backend_plt_alignment 4
-static const struct elf_i386_backend_data elf_i386_vxworks_arch_bed =
+static const struct elf_x86_backend_data elf_i386_vxworks_arch_bed =
{
- 0x90, /* plt0_pad_byte */
is_vxworks /* os */
};
projects / deliverable / binutils-gdb.git / blobdiff