X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=bfd%2Felf32-i386.c;h=e32ec831c72b03bb5ca4221f282e155e823de244;hb=b70321a200b768e57b211fce3f6926b2b29dee7f;hp=610c709959f21f78bc0ec11cab6b62333ad65e0e;hpb=6de2ae4a2a0020a827f05f30dedf8dcec7e77ee0;p=binutils-gdb.git diff --git a/bfd/elf32-i386.c b/bfd/elf32-i386.c index 610c709959f..e32ec831c72 100644 --- a/bfd/elf32-i386.c +++ b/bfd/elf32-i386.c @@ -1,6 +1,7 @@ /* Intel 80386/80486-specific support for 32-bit ELF Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, - 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc. + 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 + Free Software Foundation, Inc. This file is part of BFD, the Binary File Descriptor library. @@ -323,7 +324,7 @@ elf_i386_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, case BFD_RELOC_386_IRELATIVE: TRACE ("BFD_RELOC_386_IRELATIVE"); - return &elf_howto_table[R_386_IRELATIVE]; + return &elf_howto_table[R_386_IRELATIVE - R_386_tls_offset]; case BFD_RELOC_VTABLE_INHERIT: TRACE ("BFD_RELOC_VTABLE_INHERIT"); @@ -419,7 +420,7 @@ elf_i386_grok_prstatus (bfd *abfd, Elf_Internal_Note *note) elf_tdata (abfd)->core_signal = bfd_get_32 (abfd, note->descdata + 20); /* pr_pid */ - elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24); + elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 24); /* pr_reg */ offset = 28; @@ -437,7 +438,7 @@ elf_i386_grok_prstatus (bfd *abfd, Elf_Internal_Note *note) elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12); /* pr_pid */ - elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24); + elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 24); /* pr_reg */ offset = 72; @@ -475,6 +476,8 @@ elf_i386_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) return FALSE; case 124: /* Linux/i386 elf_prpsinfo. */ + elf_tdata (abfd)->core_pid + = bfd_get_32 (abfd, note->descdata + 12); elf_tdata (abfd)->core_program = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16); elf_tdata (abfd)->core_command @@ -577,26 +580,6 @@ static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] = #define PLTRESOLVE_RELOCS 2 #define PLT_NON_JUMP_SLOT_RELOCS 2 -/* The i386 linker needs to keep track of the number of relocs that it - decides to copy as dynamic relocs in check_relocs for each symbol. - This is so that it can later discard them if they are found to be - unnecessary. We store the information in a field extending the - regular ELF linker hash table. */ - -struct elf_i386_dyn_relocs -{ - struct elf_i386_dyn_relocs *next; - - /* The input section of the reloc. */ - asection *sec; - - /* Total number of relocs copied for the input section. */ - bfd_size_type count; - - /* Number of pc-relative relocs copied for the input section. */ - bfd_size_type pc_count; -}; - /* i386 ELF linker hash entry. */ struct elf_i386_link_hash_entry @@ -604,7 +587,7 @@ struct elf_i386_link_hash_entry struct elf_link_hash_entry elf; /* Track dynamic relocs copied for this symbol. */ - struct elf_i386_dyn_relocs *dyn_relocs; + struct elf_dyn_relocs *dyn_relocs; #define GOT_UNKNOWN 0 #define GOT_NORMAL 1 @@ -654,13 +637,13 @@ struct elf_i386_obj_tdata #define is_i386_elf(bfd) \ (bfd_get_flavour (bfd) == bfd_target_elf_flavour \ && elf_tdata (bfd) != NULL \ - && elf_object_id (bfd) == I386_ELF_TDATA) + && elf_object_id (bfd) == I386_ELF_DATA) static bfd_boolean elf_i386_mkobject (bfd *abfd) { return bfd_elf_allocate_object (abfd, sizeof (struct elf_i386_obj_tdata), - I386_ELF_TDATA); + I386_ELF_DATA); } /* i386 ELF linker hash table. */ @@ -673,19 +656,8 @@ struct elf_i386_link_hash_table asection *sdynbss; asection *srelbss; - /* The (unloaded but important) .rel.plt.unloaded section on VxWorks. */ - asection *srelplt2; - - /* True if the target system is VxWorks. */ - int is_vxworks; - - /* Value used to fill the last word of the first plt entry. */ - bfd_byte plt0_pad_byte; - - /* The index of the next unused R_386_TLS_DESC slot in .rel.plt. */ - bfd_vma next_tls_desc_index; - - union { + union + { bfd_signed_vma refcount; bfd_vma offset; } tls_ldm_got; @@ -694,21 +666,34 @@ struct elf_i386_link_hash_table section, plus whatever space is used by the jump slots. */ bfd_vma sgotplt_jump_table_size; - /* Small local sym to section mapping cache. */ - struct sym_sec_cache sym_sec; + /* Small local sym cache. */ + struct sym_cache sym_cache; /* _TLS_MODULE_BASE_ symbol. */ struct bfd_link_hash_entry *tls_module_base; /* Used by local STT_GNU_IFUNC symbols. */ htab_t loc_hash_table; - void *loc_hash_memory; + void * loc_hash_memory; + + /* The (unloaded but important) .rel.plt.unloaded section on VxWorks. */ + asection *srelplt2; + + /* True if the target system is VxWorks. */ + int is_vxworks; + + /* The index of the next unused R_386_TLS_DESC slot in .rel.plt. */ + bfd_vma next_tls_desc_index; + + /* Value used to fill the last word of the first plt entry. */ + bfd_byte plt0_pad_byte; }; /* Get the i386 ELF linker hash table from a link_info structure. */ #define elf_i386_hash_table(p) \ - ((struct elf_i386_link_hash_table *) ((p)->hash)) + (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \ + == I386_ELF_DATA ? ((struct elf_i386_link_hash_table *) ((p)->hash)) : NULL) #define elf_i386_compute_jump_table_size(htab) \ ((htab)->next_tls_desc_index * 4) @@ -724,8 +709,8 @@ elf_i386_link_hash_newfunc (struct bfd_hash_entry *entry, subclass. */ if (entry == NULL) { - entry = bfd_hash_allocate (table, - sizeof (struct elf_i386_link_hash_entry)); + entry = (struct bfd_hash_entry *) + bfd_hash_allocate (table, sizeof (struct elf_i386_link_hash_entry)); if (entry == NULL) return entry; } @@ -745,13 +730,6 @@ elf_i386_link_hash_newfunc (struct bfd_hash_entry *entry, return entry; } -static hashval_t -elf_i386_local_hash (int id, int r_sym) -{ - return ((((id & 0xff) << 24) | ((id & 0xff00) << 8)) - ^ r_sym ^ (id >> 16)); -} - /* Compute a hash of a local hash entry. We use elf_link_hash_entry for local symbol so that we can handle local STT_GNU_IFUNC symbols as global symbol. We reuse indx and dynstr_index for local symbol @@ -762,7 +740,7 @@ elf_i386_local_htab_hash (const void *ptr) { struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) ptr; - return elf_i386_local_hash (h->indx, h->dynstr_index); + return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index); } /* Compare local hash entries. */ @@ -787,8 +765,8 @@ elf_i386_get_local_sym_hash (struct elf_i386_link_hash_table *htab, { struct elf_i386_link_hash_entry e, *ret; asection *sec = abfd->sections; - hashval_t h = elf_i386_local_hash (sec->id, - ELF32_R_SYM (rel->r_info)); + hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id, + ELF32_R_SYM (rel->r_info)); void **slot; e.elf.indx = sec->id; @@ -814,8 +792,6 @@ elf_i386_get_local_sym_hash (struct elf_i386_link_hash_table *htab, ret->elf.indx = sec->id; ret->elf.dynstr_index = ELF32_R_SYM (rel->r_info); ret->elf.dynindx = -1; - ret->elf.plt.offset = (bfd_vma) -1; - ret->elf.got.offset = (bfd_vma) -1; *slot = ret; } return &ret->elf; @@ -829,13 +805,14 @@ elf_i386_link_hash_table_create (bfd *abfd) struct elf_i386_link_hash_table *ret; bfd_size_type amt = sizeof (struct elf_i386_link_hash_table); - ret = bfd_malloc (amt); + ret = (struct elf_i386_link_hash_table *) bfd_malloc (amt); if (ret == NULL) return NULL; if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, elf_i386_link_hash_newfunc, - sizeof (struct elf_i386_link_hash_entry))) + sizeof (struct elf_i386_link_hash_entry), + I386_ELF_DATA)) { free (ret); return NULL; @@ -846,7 +823,7 @@ elf_i386_link_hash_table_create (bfd *abfd) ret->tls_ldm_got.refcount = 0; ret->next_tls_desc_index = 0; ret->sgotplt_jump_table_size = 0; - ret->sym_sec.abfd = NULL; + ret->sym_cache.abfd = NULL; ret->is_vxworks = 0; ret->srelplt2 = NULL; ret->plt0_pad_byte = 0; @@ -894,6 +871,9 @@ elf_i386_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info) return FALSE; htab = elf_i386_hash_table (info); + if (htab == NULL) + return FALSE; + htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss"); if (!info->shared) htab->srelbss = bfd_get_section_by_name (dynobj, ".rel.bss"); @@ -926,14 +906,14 @@ elf_i386_copy_indirect_symbol (struct bfd_link_info *info, { if (edir->dyn_relocs != NULL) { - struct elf_i386_dyn_relocs **pp; - struct elf_i386_dyn_relocs *p; + struct elf_dyn_relocs **pp; + struct elf_dyn_relocs *p; /* Add reloc counts against the indirect sym to the direct sym list. Merge any entries against the same section. */ for (pp = &eind->dyn_relocs; (p = *pp) != NULL; ) { - struct elf_i386_dyn_relocs *q; + struct elf_dyn_relocs *q; for (q = edir->dyn_relocs; q != NULL; q = q->next) if (q->sec == p->sec) @@ -1176,12 +1156,19 @@ elf_i386_tls_transition (struct bfd_link_info *info, bfd *abfd, unsigned int *r_type, int tls_type, const Elf_Internal_Rela *rel, const Elf_Internal_Rela *relend, - struct elf_link_hash_entry *h) + struct elf_link_hash_entry *h, + unsigned long r_symndx) { unsigned int from_type = *r_type; unsigned int to_type = from_type; bfd_boolean check = TRUE; + /* Skip TLS transition for functions. */ + if (h != NULL + && (h->type == STT_FUNC + || h->type == STT_GNU_IFUNC)) + return TRUE; + switch (from_type) { case R_386_TLS_GD: @@ -1190,7 +1177,7 @@ elf_i386_tls_transition (struct bfd_link_info *info, bfd *abfd, case R_386_TLS_IE_32: case R_386_TLS_IE: case R_386_TLS_GOTIE: - if (!info->shared) + if (info->executable) { if (h == NULL) to_type = R_386_TLS_LE_32; @@ -1206,7 +1193,7 @@ elf_i386_tls_transition (struct bfd_link_info *info, bfd *abfd, { unsigned int new_to_type = to_type; - if (!info->shared + if (info->executable && h != NULL && h->dynindx == -1 && (tls_type & GOT_TLS_IE)) @@ -1232,7 +1219,7 @@ elf_i386_tls_transition (struct bfd_link_info *info, bfd *abfd, break; case R_386_TLS_LDM: - if (!info->shared) + if (info->executable) to_type = R_386_TLS_LE_32; break; @@ -1251,15 +1238,34 @@ elf_i386_tls_transition (struct bfd_link_info *info, bfd *abfd, from_type, rel, relend)) { reloc_howto_type *from, *to; + const char *name; from = elf_i386_rtype_to_howto (abfd, from_type); to = elf_i386_rtype_to_howto (abfd, to_type); + if (h) + name = h->root.root.string; + else + { + struct elf_i386_link_hash_table *htab; + + htab = elf_i386_hash_table (info); + if (htab == NULL) + name = "*unknown*"; + else + { + Elf_Internal_Sym *isym; + + isym = bfd_sym_from_r_symndx (&htab->sym_cache, + abfd, r_symndx); + name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL); + } + } + (*_bfd_error_handler) (_("%B: TLS transition from %s to %s against `%s' at 0x%lx " "in section `%A' failed"), - abfd, sec, from->name, to->name, - h ? h->root.root.string : "a local symbol", + abfd, sec, from->name, to->name, name, (unsigned long) rel->r_offset); bfd_set_error (bfd_error_bad_value); return FALSE; @@ -1285,7 +1291,6 @@ elf_i386_check_relocs (bfd *abfd, const Elf_Internal_Rela *rel; const Elf_Internal_Rela *rel_end; asection *sreloc; - Elf_Internal_Sym *isymbuf; if (info->relocatable) return TRUE; @@ -1293,8 +1298,10 @@ elf_i386_check_relocs (bfd *abfd, BFD_ASSERT (is_i386_elf (abfd)); htab = elf_i386_hash_table (info); + if (htab == NULL) + return FALSE; + symtab_hdr = &elf_symtab_hdr (abfd); - isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; sym_hashes = elf_sym_hashes (abfd); sreloc = NULL; @@ -1305,6 +1312,8 @@ elf_i386_check_relocs (bfd *abfd, unsigned int r_type; unsigned long r_symndx; struct elf_link_hash_entry *h; + Elf_Internal_Sym *isym; + const char *name; r_symndx = ELF32_R_SYM (rel->r_info); r_type = ELF32_R_TYPE (rel->r_info); @@ -1320,28 +1329,18 @@ elf_i386_check_relocs (bfd *abfd, if (r_symndx < symtab_hdr->sh_info) { /* A local symbol. */ - Elf_Internal_Sym *isym; - - /* Read this BFD's local symbols. */ - if (isymbuf == NULL) - { - if (isymbuf == NULL) - isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, - symtab_hdr->sh_info, 0, - NULL, NULL, NULL); - if (isymbuf == NULL) - return FALSE; - } + isym = bfd_sym_from_r_symndx (&htab->sym_cache, + abfd, r_symndx); + if (isym == NULL) + return FALSE; /* Check relocation against local STT_GNU_IFUNC symbol. */ - isym = isymbuf + r_symndx; if (ELF32_ST_TYPE (isym->st_info) == STT_GNU_IFUNC) { - h = elf_i386_get_local_sym_hash (htab, abfd, rel, - TRUE); + h = elf_i386_get_local_sym_hash (htab, abfd, rel, TRUE); if (h == NULL) return FALSE; - + /* Fake a STT_GNU_IFUNC symbol. */ h->type = STT_GNU_IFUNC; h->def_regular = 1; @@ -1354,6 +1353,7 @@ elf_i386_check_relocs (bfd *abfd, } else { + isym = NULL; h = sym_hashes[r_symndx - symtab_hdr->sh_info]; while (h->root.type == bfd_link_hash_indirect || h->root.type == bfd_link_hash_warning) @@ -1388,7 +1388,8 @@ elf_i386_check_relocs (bfd *abfd, { /* It is referenced by a non-shared object. */ h->ref_regular = 1; - + h->needs_plt = 1; + /* STT_GNU_IFUNC symbol must go through PLT. */ h->plt.refcount += 1; @@ -1399,13 +1400,16 @@ elf_i386_check_relocs (bfd *abfd, switch (r_type) { default: + if (h->root.root.string) + name = h->root.root.string; + else + name = bfd_elf_sym_name (abfd, symtab_hdr, isym, + NULL); (*_bfd_error_handler) (_("%B: relocation %s against STT_GNU_IFUNC " "symbol `%s' isn't handled by %s"), abfd, elf_howto_table[r_type].name, - (h->root.root.string - ? h->root.root.string : "a local symbol"), - __FUNCTION__); + name, __FUNCTION__); bfd_set_error (bfd_error_bad_value); return FALSE; @@ -1414,39 +1418,14 @@ elf_i386_check_relocs (bfd *abfd, h->pointer_equality_needed = 1; if (info->shared) { - struct elf_i386_dyn_relocs *p; - struct elf_i386_dyn_relocs **head; - /* We must copy these reloc types into the output file. Create a reloc section in dynobj and make room for this reloc. */ + sreloc = _bfd_elf_create_ifunc_dyn_reloc + (abfd, info, sec, sreloc, + &((struct elf_i386_link_hash_entry *) h)->dyn_relocs); if (sreloc == NULL) - { - if (htab->elf.dynobj == NULL) - htab->elf.dynobj = abfd; - - sreloc = _bfd_elf_make_dynamic_reloc_section - (sec, htab->elf.dynobj, 2, abfd, FALSE); - - if (sreloc == NULL) - return FALSE; - } - - head = &((struct elf_i386_link_hash_entry *) h)->dyn_relocs; - p = *head; - if (p == NULL || p->sec != sec) - { - bfd_size_type amt = sizeof *p; - p = bfd_alloc (htab->elf.dynobj, amt); - if (p == NULL) - return FALSE; - p->next = *head; - *head = p; - p->sec = sec; - p->count = 0; - p->pc_count = 0; - } - p->count += 1; + return FALSE; } break; @@ -1474,7 +1453,7 @@ elf_i386_check_relocs (bfd *abfd, if (! elf_i386_tls_transition (info, abfd, sec, NULL, symtab_hdr, sym_hashes, &r_type, GOT_UNKNOWN, - rel, rel_end, h)) + rel, rel_end, h, r_symndx)) return FALSE; switch (r_type) @@ -1503,7 +1482,7 @@ elf_i386_check_relocs (bfd *abfd, case R_386_TLS_IE_32: case R_386_TLS_IE: case R_386_TLS_GOTIE: - if (info->shared) + if (!info->executable) info->flags |= DF_STATIC_TLS; /* Fall through */ @@ -1554,7 +1533,8 @@ elf_i386_check_relocs (bfd *abfd, size = symtab_hdr->sh_info; size *= (sizeof (bfd_signed_vma) + sizeof (bfd_vma) + sizeof(char)); - local_got_refcounts = bfd_zalloc (abfd, size); + local_got_refcounts = (bfd_signed_vma *) + bfd_zalloc (abfd, size); if (local_got_refcounts == NULL) return FALSE; elf_local_got_refcounts (abfd) = local_got_refcounts; @@ -1582,11 +1562,15 @@ elf_i386_check_relocs (bfd *abfd, tls_type |= old_tls_type; else { + if (h) + name = h->root.root.string; + else + name = bfd_elf_sym_name (abfd, symtab_hdr, isym, + NULL); (*_bfd_error_handler) (_("%B: `%s' accessed both as normal and " "thread local symbol"), - abfd, - h ? h->root.root.string : ""); + abfd, name); return FALSE; } } @@ -1617,7 +1601,7 @@ elf_i386_check_relocs (bfd *abfd, case R_386_TLS_LE_32: case R_386_TLS_LE: - if (!info->shared) + if (info->executable) break; info->flags |= DF_STATIC_TLS; /* Fall through */ @@ -1676,8 +1660,8 @@ elf_i386_check_relocs (bfd *abfd, && (h->root.type == bfd_link_hash_defweak || !h->def_regular))) { - struct elf_i386_dyn_relocs *p; - struct elf_i386_dyn_relocs **head; + struct elf_dyn_relocs *p; + struct elf_dyn_relocs **head; /* We must copy these reloc types into the output file. Create a reloc section in dynobj and make room for @@ -1702,26 +1686,31 @@ elf_i386_check_relocs (bfd *abfd, } else { - void **vpp; /* Track dynamic relocs needed for local syms too. We really need local syms available to do this easily. Oh well. */ - + void **vpp; asection *s; - s = bfd_section_from_r_symndx (abfd, &htab->sym_sec, - sec, r_symndx); - if (s == NULL) + + isym = bfd_sym_from_r_symndx (&htab->sym_cache, + abfd, r_symndx); + if (isym == NULL) return FALSE; + s = bfd_section_from_elf_index (abfd, isym->st_shndx); + if (s == NULL) + s = sec; + vpp = &elf_section_data (s)->local_dynrel; - head = (struct elf_i386_dyn_relocs **)vpp; + head = (struct elf_dyn_relocs **)vpp; } p = *head; if (p == NULL || p->sec != sec) { bfd_size_type amt = sizeof *p; - p = bfd_alloc (htab->elf.dynobj, amt); + p = (struct elf_dyn_relocs *) bfd_alloc (htab->elf.dynobj, + amt); if (p == NULL) return FALSE; p->next = *head; @@ -1790,6 +1779,7 @@ elf_i386_gc_sweep_hook (bfd *abfd, asection *sec, const Elf_Internal_Rela *relocs) { + struct elf_i386_link_hash_table *htab; Elf_Internal_Shdr *symtab_hdr; struct elf_link_hash_entry **sym_hashes; bfd_signed_vma *local_got_refcounts; @@ -1798,6 +1788,10 @@ elf_i386_gc_sweep_hook (bfd *abfd, if (info->relocatable) return TRUE; + htab = elf_i386_hash_table (info); + if (htab == NULL) + return FALSE; + elf_section_data (sec)->local_dynrel = NULL; symtab_hdr = &elf_symtab_hdr (abfd); @@ -1814,16 +1808,36 @@ elf_i386_gc_sweep_hook (bfd *abfd, r_symndx = ELF32_R_SYM (rel->r_info); if (r_symndx >= symtab_hdr->sh_info) { - struct elf_i386_link_hash_entry *eh; - struct elf_i386_dyn_relocs **pp; - struct elf_i386_dyn_relocs *p; - 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; - eh = (struct elf_i386_link_hash_entry *) h; + } + else + { + /* A local symbol. */ + Elf_Internal_Sym *isym; + isym = bfd_sym_from_r_symndx (&htab->sym_cache, + abfd, r_symndx); + + /* Check relocation against local STT_GNU_IFUNC symbol. */ + if (isym != NULL + && ELF32_ST_TYPE (isym->st_info) == STT_GNU_IFUNC) + { + h = elf_i386_get_local_sym_hash (htab, abfd, rel, FALSE); + if (h == NULL) + abort (); + } + } + + if (h) + { + struct elf_i386_link_hash_entry *eh; + struct elf_dyn_relocs **pp; + struct elf_dyn_relocs *p; + + eh = (struct elf_i386_link_hash_entry *) h; for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next) if (p->sec == sec) { @@ -1837,14 +1851,14 @@ elf_i386_gc_sweep_hook (bfd *abfd, if (! elf_i386_tls_transition (info, abfd, sec, NULL, symtab_hdr, sym_hashes, &r_type, GOT_UNKNOWN, - rel, relend, h)) + rel, relend, h, r_symndx)) return FALSE; switch (r_type) { case R_386_TLS_LDM: - if (elf_i386_hash_table (info)->tls_ldm_got.refcount > 0) - elf_i386_hash_table (info)->tls_ldm_got.refcount -= 1; + if (htab->tls_ldm_got.refcount > 0) + htab->tls_ldm_got.refcount -= 1; break; case R_386_TLS_GD: @@ -1858,6 +1872,11 @@ elf_i386_gc_sweep_hook (bfd *abfd, { if (h->got.refcount > 0) h->got.refcount -= 1; + if (h->type == STT_GNU_IFUNC) + { + if (h->plt.refcount > 0) + h->plt.refcount -= 1; + } } else if (local_got_refcounts != NULL) { @@ -1868,7 +1887,8 @@ elf_i386_gc_sweep_hook (bfd *abfd, case R_386_32: case R_386_PC32: - if (info->shared) + if (info->shared + && (h == NULL || h->type != STT_GNU_IFUNC)) break; /* Fall through */ @@ -1880,6 +1900,16 @@ elf_i386_gc_sweep_hook (bfd *abfd, } break; + case R_386_GOTOFF: + if (h != NULL && h->type == STT_GNU_IFUNC) + { + if (h->got.refcount > 0) + h->got.refcount -= 1; + if (h->plt.refcount > 0) + h->plt.refcount -= 1; + } + break; + default: break; } @@ -1979,6 +2009,8 @@ elf_i386_adjust_dynamic_symbol (struct bfd_link_info *info, } htab = elf_i386_hash_table (info); + if (htab == NULL) + return FALSE; /* If there aren't any dynamic relocs in read-only sections, then we can keep the dynamic relocs and avoid the copy reloc. This @@ -1987,7 +2019,7 @@ elf_i386_adjust_dynamic_symbol (struct bfd_link_info *info, if (ELIMINATE_COPY_RELOCS && !htab->is_vxworks) { struct elf_i386_link_hash_entry * eh; - struct elf_i386_dyn_relocs *p; + struct elf_dyn_relocs *p; eh = (struct elf_i386_link_hash_entry *) h; for (p = eh->dyn_relocs; p != NULL; p = p->next) @@ -2044,7 +2076,7 @@ elf_i386_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf) struct bfd_link_info *info; struct elf_i386_link_hash_table *htab; struct elf_i386_link_hash_entry *eh; - struct elf_i386_dyn_relocs *p; + struct elf_dyn_relocs *p; if (h->root.type == bfd_link_hash_indirect) return TRUE; @@ -2058,128 +2090,16 @@ elf_i386_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf) info = (struct bfd_link_info *) inf; htab = elf_i386_hash_table (info); + if (htab == NULL) + return FALSE; /* 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) - { - asection *plt, *gotplt, *relplt; - - /* When a shared library references a STT_GNU_IFUNC symbol - defined in executable, the address of the resolved function - may be used. But in non-shared executable, the address of - its .plt slot may be used. Pointer equality may not work - correctly. PIE should be used if pointer equality is - required here. */ - if (!info->shared - && (h->dynindx != -1 - || info->export_dynamic) - && h->pointer_equality_needed) - { - info->callbacks->einfo - (_("%F%P: dynamic STT_GNU_IFUNC symbol `%s' with pointer " - "equality in `%B' can not be used when making an " - "executable; recompile with -fPIE and relink with -pie\n"), - h->root.root.string, - h->root.u.def.section->owner); - bfd_set_error (bfd_error_bad_value); - return FALSE; - } - - /* Return and discard space for dynamic relocations against it if - it is never referenced in a non-shared object. */ - if (!h->ref_regular) - { - if (h->plt.refcount > 0 - || h->got.refcount > 0) - abort (); - h->got.offset = (bfd_vma) -1; - eh->dyn_relocs = NULL; - return TRUE; - } - - /* When building a static executable, use .iplt, .igot.plt and - .rel.iplt sections for STT_GNU_IFUNC symbols. */ - if (htab->elf.splt != NULL) - { - plt = htab->elf.splt; - gotplt = htab->elf.sgotplt; - relplt = htab->elf.srelplt; - - /* If this is the first .plt entry, make room for the special - first entry. */ - if (plt->size == 0) - plt->size += PLT_ENTRY_SIZE; - } - else - { - plt = htab->elf.iplt; - gotplt = htab->elf.igotplt; - relplt = htab->elf.irelplt; - } - - /* Don't update value of STT_GNU_IFUNC symbol to PLT. We need - the original value for R_386_IRELATIVE. */ - h->plt.offset = plt->size; - - /* Make room for this entry in the .plt/.iplt section. */ - plt->size += PLT_ENTRY_SIZE; - - /* We also need to make an entry in the .got.plt/.got.iplt - section, which will be placed in the .got section by the - linker script. */ - gotplt->size += 4; - - /* We also need to make an entry in the .rela.plt/.rela.iplt - section. */ - relplt->size += sizeof (Elf32_External_Rel); - relplt->reloc_count++; - - /* We need dynamic relocation for STT_GNU_IFUNC symbol only - when there is a non-GOT reference in a shared object. */ - if (!info->shared - || !h->non_got_ref) - eh->dyn_relocs = NULL; - - /* Finally, allocate space. */ - for (p = eh->dyn_relocs; p != NULL; p = p->next) - htab->elf.irelifunc->size += p->count * sizeof (Elf32_External_Rel); - - /* For STT_GNU_IFUNC symbol, .got.plt has the real function - addres and .got has the PLT entry adddress. We will load - the GOT entry with the PLT entry in finish_dynamic_symbol if - it is used. For branch, it uses .got.plt. For symbol value, - 1. Use .got.plt in a shared object if it is forced local or - not dynamic. - 2. Use .got.plt in a non-shared object if pointer equality - isn't needed. - 3. Use .got.plt in PIE. - 4. Use .got.plt if .got isn't used. - 5. Otherwise use .got so that it can be shared among different - objects at run-time. - We only need to relocate .got entry in shared object. */ - if ((info->shared - && (h->dynindx == -1 - || h->forced_local)) - || (!info->shared - && !h->pointer_equality_needed) - || (info->executable && info->shared) - || htab->elf.sgot == NULL) - { - /* Use .got.plt. */ - h->got.offset = (bfd_vma) -1; - } - else - { - h->got.offset = htab->elf.sgot->size; - htab->elf.sgot->size += 4; - if (info->shared) - htab->elf.srelgot->size += sizeof (Elf32_External_Rel); - } - - return TRUE; - } + return _bfd_elf_allocate_ifunc_dyn_relocs (info, h, + &eh->dyn_relocs, + PLT_ENTRY_SIZE, 4); else if (htab->elf.dynamic_sections_created && h->plt.refcount > 0) { @@ -2264,7 +2184,7 @@ elf_i386_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf) /* 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 - && !info->shared + && info->executable && h->dynindx == -1 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE)) h->got.offset = (bfd_vma) -1; @@ -2344,7 +2264,7 @@ elf_i386_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf) should avoid writing assembly like ".long foo - .". */ if (SYMBOL_CALLS_LOCAL (info, h)) { - struct elf_i386_dyn_relocs **pp; + struct elf_dyn_relocs **pp; for (pp = &eh->dyn_relocs; (p = *pp) != NULL; ) { @@ -2359,7 +2279,7 @@ elf_i386_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf) if (htab->is_vxworks) { - struct elf_i386_dyn_relocs **pp; + struct elf_dyn_relocs **pp; for (pp = &eh->dyn_relocs; (p = *pp) != NULL; ) { if (strcmp (p->sec->output_section->name, ".tls_vars") == 0) @@ -2459,11 +2379,15 @@ static bfd_boolean elf_i386_readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf) { struct elf_i386_link_hash_entry *eh; - struct elf_i386_dyn_relocs *p; + struct elf_dyn_relocs *p; if (h->root.type == bfd_link_hash_warning) h = (struct elf_link_hash_entry *) h->root.u.i.link; + /* Skip local IFUNC symbols. */ + if (h->forced_local && h->type == STT_GNU_IFUNC) + return TRUE; + eh = (struct elf_i386_link_hash_entry *) h; for (p = eh->dyn_relocs; p != NULL; p = p->next) { @@ -2475,6 +2399,11 @@ elf_i386_readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf) info->flags |= DF_TEXTREL; + if (info->warn_shared_textrel && info->shared) + info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'.\n"), + p->sec->owner, h->root.root.string, + p->sec); + /* Not an error, just cut short the traversal. */ return FALSE; } @@ -2495,6 +2424,8 @@ elf_i386_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, bfd *ibfd; htab = elf_i386_hash_table (info); + if (htab == NULL) + return FALSE; dynobj = htab->elf.dynobj; if (dynobj == NULL) abort (); @@ -2529,9 +2460,9 @@ elf_i386_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, for (s = ibfd->sections; s != NULL; s = s->next) { - struct elf_i386_dyn_relocs *p; + struct elf_dyn_relocs *p; - for (p = ((struct elf_i386_dyn_relocs *) + for (p = ((struct elf_dyn_relocs *) elf_section_data (s)->local_dynrel); p != NULL; p = p->next) @@ -2556,7 +2487,13 @@ elf_i386_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, 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; + { + info->flags |= DF_TEXTREL; + if (info->warn_shared_textrel && info->shared) + info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'.\n"), + p->sec->owner, p->sec); + break; + } } } } @@ -2640,6 +2577,30 @@ elf_i386_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, if (htab->elf.srelplt) htab->sgotplt_jump_table_size = htab->next_tls_desc_index * 4; + if (htab->elf.sgotplt) + { + struct elf_link_hash_entry *got; + got = elf_link_hash_lookup (elf_hash_table (info), + "_GLOBAL_OFFSET_TABLE_", + FALSE, FALSE, FALSE); + + /* Don't allocate .got.plt section if there are no GOT nor PLT + entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */ + if ((got == NULL + || !got->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; + } + /* We now have determined the sizes of the various dynamic sections. Allocate memory for them. */ relocs = FALSE; @@ -2707,7 +2668,7 @@ elf_i386_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, 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 = bfd_zalloc (dynobj, s->size); + s->contents = (unsigned char *) bfd_zalloc (dynobj, s->size); if (s->contents == NULL) return FALSE; } @@ -2781,17 +2742,22 @@ elf_i386_always_size_sections (bfd *output_bfd, if (tlsbase && tlsbase->type == STT_TLS) { + struct elf_i386_link_hash_table *htab; struct bfd_link_hash_entry *bh = NULL; const struct elf_backend_data *bed = get_elf_backend_data (output_bfd); + htab = elf_i386_hash_table (info); + if (htab == NULL) + return FALSE; + if (!(_bfd_generic_link_add_one_symbol (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL, tls_sec, 0, NULL, FALSE, bed->collect, &bh))) return FALSE; - elf_i386_hash_table (info)->tls_module_base = bh; + htab->tls_module_base = bh; tlsbase = (struct elf_link_hash_entry *)bh; tlsbase->def_regular = 1; @@ -2811,7 +2777,7 @@ elf_i386_fake_sections (bfd *abfd ATTRIBUTE_UNUSED, Elf_Internal_Shdr *hdr, asection *sec) { - register const char *name; + const char *name; name = bfd_get_section_name (abfd, sec); @@ -2845,17 +2811,21 @@ elf_i386_fake_sections (bfd *abfd ATTRIBUTE_UNUSED, static void elf_i386_set_tls_module_base (struct bfd_link_info *info) { + struct elf_i386_link_hash_table *htab; struct bfd_link_hash_entry *base; if (!info->executable) return; - base = elf_i386_hash_table (info)->tls_module_base; + htab = elf_i386_hash_table (info); + if (htab == NULL) + return; - if (!base) + base = htab->tls_module_base; + if (base == NULL) return; - base->u.def.value = elf_hash_table (info)->tls_size; + base->u.def.value = htab->elf.tls_size; } /* Return the base VMA address which should be subtracted from real addresses @@ -2878,11 +2848,16 @@ static bfd_vma elf_i386_tpoff (struct bfd_link_info *info, bfd_vma address) { struct elf_link_hash_table *htab = elf_hash_table (info); + const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd); + bfd_vma static_tls_size; /* If tls_sec is NULL, we should have signalled an error already. */ if (htab->tls_sec == NULL) return 0; - return htab->tls_size + htab->tls_sec->vma - address; + + /* Consider special static TLS alignment requirements. */ + static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment); + return static_tls_size + htab->tls_sec->vma - address; } /* Relocate an i386 ELF section. */ @@ -2907,8 +2882,10 @@ elf_i386_relocate_section (bfd *output_bfd, bfd_boolean is_vxworks_tls; BFD_ASSERT (is_i386_elf (input_bfd)); - + htab = elf_i386_hash_table (info); + if (htab == NULL) + return FALSE; symtab_hdr = &elf_symtab_hdr (input_bfd); sym_hashes = elf_sym_hashes (input_bfd); local_got_offsets = elf_local_got_offsets (input_bfd); @@ -3039,11 +3016,12 @@ elf_i386_relocate_section (bfd *output_bfd, break; } } - else if (ELF32_ST_TYPE (sym->st_info) == STT_GNU_IFUNC) + else if (!info->relocatable + && ELF32_ST_TYPE (sym->st_info) == STT_GNU_IFUNC) { /* Relocate against local STT_GNU_IFUNC symbol. */ - h = elf_i386_get_local_sym_hash (htab, input_bfd, - rel, FALSE); + h = elf_i386_get_local_sym_hash (htab, input_bfd, rel, + FALSE); if (h == NULL) abort (); @@ -3054,7 +3032,7 @@ elf_i386_relocate_section (bfd *output_bfd, } else { - bfd_boolean warned; + bfd_boolean warned ATTRIBUTE_UNUSED; RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, r_symndx, symtab_hdr, sym_hashes, @@ -3063,15 +3041,8 @@ elf_i386_relocate_section (bfd *output_bfd, } if (sec != NULL && elf_discarded_section (sec)) - { - /* For relocs against symbols from removed linkonce sections, - or sections discarded by a linker script, we just want the - section contents zeroed. Avoid any special processing. */ - _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset); - rel->r_info = 0; - rel->r_addend = 0; - continue; - } + RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, + rel, relend, howto, contents); if (info->relocatable) continue; @@ -3084,6 +3055,7 @@ elf_i386_relocate_section (bfd *output_bfd, { asection *plt, *gotplt, *base_got; bfd_vma plt_index; + const char *name; if ((input_section->flags & SEC_ALLOC) == 0 || h->plt.offset == (bfd_vma) -1) @@ -3107,13 +3079,16 @@ elf_i386_relocate_section (bfd *output_bfd, switch (r_type) { default: + if (h->root.root.string) + name = h->root.root.string; + else + name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, + NULL); (*_bfd_error_handler) (_("%B: relocation %s against STT_GNU_IFUNC " "symbol `%s' isn't handled by %s"), input_bfd, elf_howto_table[r_type].name, - (h->root.root.string - ? h->root.root.string : "a local symbol"), - __FUNCTION__); + name, __FUNCTION__); bfd_set_error (bfd_error_bad_value); return FALSE; @@ -3169,7 +3144,7 @@ elf_i386_relocate_section (bfd *output_bfd, internal symbol, we have updated addend. */ continue; } - + /* FALLTHROUGH */ case R_386_PC32: case R_386_PLT32: goto do_relocation; @@ -3186,7 +3161,7 @@ elf_i386_relocate_section (bfd *output_bfd, /* We can't use h->got.offset here to save state, or even just remember the offset, as finish_dynamic_symbol would use that as offset into .got. */ - + if (htab->elf.splt != NULL) { plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1; @@ -3492,7 +3467,11 @@ elf_i386_relocate_section (bfd *output_bfd, sreloc = elf_section_data (input_section)->sreloc; - BFD_ASSERT (sreloc != NULL && sreloc->contents != NULL); + if (sreloc == NULL || sreloc->contents == NULL) + { + r = bfd_reloc_notsupported; + goto check_relocation_error; + } loc = sreloc->contents; loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel); @@ -3509,7 +3488,7 @@ elf_i386_relocate_section (bfd *output_bfd, break; case R_386_TLS_IE: - if (info->shared) + if (!info->executable) { Elf_Internal_Rela outrel; bfd_byte *loc; @@ -3545,7 +3524,7 @@ elf_i386_relocate_section (bfd *output_bfd, input_section, contents, symtab_hdr, sym_hashes, &r_type, tls_type, rel, - relend, h)) + relend, h, r_symndx)) return FALSE; if (r_type == R_386_TLS_LE_32) @@ -3618,7 +3597,7 @@ elf_i386_relocate_section (bfd *output_bfd, xchg %ax,%ax */ bfd_vma roff; - + roff = rel->r_offset; bfd_put_8 (output_bfd, 0x66, contents + roff); bfd_put_8 (output_bfd, 0x90, contents + roff + 1); @@ -3751,7 +3730,7 @@ elf_i386_relocate_section (bfd *output_bfd, { Elf_Internal_Rela outrel; bfd_byte *loc; - int dr_type, indx; + int dr_type; asection *sreloc; if (htab->elf.srelgot == NULL) @@ -4014,7 +3993,7 @@ elf_i386_relocate_section (bfd *output_bfd, input_section, contents, symtab_hdr, sym_hashes, &r_type, GOT_UNKNOWN, rel, - relend, h)) + relend, h, r_symndx)) return FALSE; if (r_type != R_386_TLS_LDM) @@ -4066,7 +4045,7 @@ elf_i386_relocate_section (bfd *output_bfd, break; case R_386_TLS_LDO_32: - if (info->shared || (input_section->flags & SEC_CODE) == 0) + if (!info->executable || (input_section->flags & SEC_CODE) == 0) relocation -= elf_i386_dtpoff_base (info); else /* When converting LDO to LE, we must negate. */ @@ -4075,12 +4054,11 @@ elf_i386_relocate_section (bfd *output_bfd, case R_386_TLS_LE_32: case R_386_TLS_LE: - if (info->shared) + if (!info->executable) { Elf_Internal_Rela outrel; asection *sreloc; bfd_byte *loc; - int indx; outrel.r_offset = rel->r_offset + input_section->output_section->vma @@ -4138,6 +4116,7 @@ do_relocation: contents, rel->r_offset, relocation, 0); +check_relocation_error: if (r != bfd_reloc_ok) { const char *name; @@ -4189,6 +4168,8 @@ elf_i386_finish_dynamic_symbol (bfd *output_bfd, struct elf_i386_link_hash_table *htab; htab = elf_i386_hash_table (info); + if (htab == NULL) + return FALSE; if (h->plt.offset != (bfd_vma) -1) { @@ -4223,7 +4204,7 @@ elf_i386_finish_dynamic_symbol (bfd *output_bfd, || plt == NULL || gotplt == NULL || relplt == NULL) - abort (); + return FALSE; /* Get the index in the procedure linkage table which corresponds to this symbol. This is the index of this symbol @@ -4233,7 +4214,7 @@ elf_i386_finish_dynamic_symbol (bfd *output_bfd, Get the offset into the .got table of the entry that corresponds to this function. Each .got entry is 4 bytes. The first three are reserved. - + For static executables, we don't reserve anything. */ if (plt == htab->elf.splt) @@ -4392,13 +4373,15 @@ elf_i386_finish_dynamic_symbol (bfd *output_bfd, } else { + asection *plt; + if (!h->pointer_equality_needed) abort (); /* For non-shared object, we can't use .got.plt, which contains the real function addres if we need pointer equality. We load the GOT entry with the PLT entry. */ - asection *plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt; + plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt; bfd_put_32 (output_bfd, (plt->output_section->vma + plt->output_offset + h->plt.offset), @@ -4506,6 +4489,9 @@ elf_i386_finish_dynamic_sections (bfd *output_bfd, asection *sdyn; htab = elf_i386_hash_table (info); + if (htab == NULL) + return FALSE; + dynobj = htab->elf.dynobj; sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); @@ -4666,6 +4652,13 @@ elf_i386_finish_dynamic_sections (bfd *output_bfd, if (htab->elf.sgotplt) { + if (bfd_is_abs_section (htab->elf.sgotplt->output_section)) + { + (*_bfd_error_handler) + (_("discarded output section: `%A'"), htab->elf.sgotplt); + return FALSE; + } + /* Fill in the first three entries in the global offset table. */ if (htab->elf.sgotplt->size > 0) { @@ -4718,7 +4711,7 @@ elf_i386_hash_symbol (struct elf_link_hash_entry *h) file. */ static bfd_boolean -elf_i386_add_symbol_hook (bfd * abfd ATTRIBUTE_UNUSED, +elf_i386_add_symbol_hook (bfd * abfd, struct bfd_link_info * info ATTRIBUTE_UNUSED, Elf_Internal_Sym * sym, const char ** namep ATTRIBUTE_UNUSED, @@ -4726,8 +4719,10 @@ elf_i386_add_symbol_hook (bfd * abfd ATTRIBUTE_UNUSED, asection ** secp ATTRIBUTE_UNUSED, bfd_vma * valp ATTRIBUTE_UNUSED) { - if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC) - elf_tdata (info->output_bfd)->has_ifunc_symbols = TRUE; + if ((abfd->flags & DYNAMIC) == 0 + && (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC + || ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE)) + elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE; return TRUE; } @@ -4735,6 +4730,7 @@ elf_i386_add_symbol_hook (bfd * abfd ATTRIBUTE_UNUSED, #define TARGET_LITTLE_SYM bfd_elf32_i386_vec #define TARGET_LITTLE_NAME "elf32-i386" #define ELF_ARCH bfd_arch_i386 +#define ELF_TARGET_ID I386_ELF_DATA #define ELF_MACHINE_CODE EM_386 #define ELF_MAXPAGESIZE 0x1000 @@ -4816,6 +4812,34 @@ elf_i386_fbsd_post_process_headers (bfd *abfd, struct bfd_link_info *info) #include "elf32-target.h" +/* Solaris 2. */ + +#undef TARGET_LITTLE_SYM +#define TARGET_LITTLE_SYM bfd_elf32_i386_sol2_vec +#undef TARGET_LITTLE_NAME +#define TARGET_LITTLE_NAME "elf32-i386-sol2" + +/* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE + objects won't be recognized. */ +#undef ELF_OSABI + +#undef elf32_bed +#define elf32_bed elf32_i386_sol2_bed + +/* The 32-bit static TLS arena size is rounded to the nearest 8-byte + boundary. */ +#undef elf_backend_static_tls_alignment +#define elf_backend_static_tls_alignment 8 + +/* The Solaris 2 ABI requires a plt symbol on all platforms. + + Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output + File, p.63. */ +#undef elf_backend_want_plt_sym +#define elf_backend_want_plt_sym 1 + +#include "elf32-target.h" + /* VxWorks support. */ #undef TARGET_LITTLE_SYM @@ -4860,6 +4884,7 @@ elf_i386_vxworks_link_hash_table_create (bfd *abfd) #undef elf_backend_final_write_processing #define elf_backend_final_write_processing \ elf_vxworks_final_write_processing +#undef elf_backend_static_tls_alignment /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so define it. */