if (!htab->sdynbss)
abort ();
- if (info->executable)
+ if (bfd_link_executable (info))
{
/* Always allow copy relocs for building executables. */
asection *s = bfd_get_linker_section (dynobj, ".rela.bss");
case R_X86_64_GOTPC32_TLSDESC:
case R_X86_64_TLSDESC_CALL:
case R_X86_64_GOTTPOFF:
- if (info->executable)
+ if (bfd_link_executable (info))
{
if (h == NULL)
to_type = R_X86_64_TPOFF32;
{
unsigned int new_to_type = to_type;
- if (info->executable
+ if (bfd_link_executable (info)
&& h != NULL
&& h->dynindx == -1
&& tls_type == GOT_TLS_IE)
break;
case R_X86_64_TLSLD:
- if (info->executable)
+ if (bfd_link_executable (info))
to_type = R_X86_64_TPOFF32;
break;
asection *sreloc;
bfd_boolean use_plt_got;
- if (info->relocatable)
+ if (bfd_link_relocatable (info))
return TRUE;
BFD_ASSERT (is_x86_64_elf (abfd));
/* It is referenced by a non-shared object. */
h->ref_regular = 1;
h->root.non_ir_ref = 1;
+
+ if (h->type == STT_GNU_IFUNC)
+ elf_tdata (info->output_bfd)->has_gnu_symbols
+ |= elf_gnu_symbol_ifunc;
}
if (! elf_x86_64_tls_transition (info, abfd, sec, NULL,
goto create_got;
case R_X86_64_TPOFF32:
- if (!info->executable && ABI_64_P (abfd))
+ if (!bfd_link_executable (info) && ABI_64_P (abfd))
{
if (h)
name = h->root.root.string;
break;
case R_X86_64_GOTTPOFF:
- if (!info->executable)
+ if (!bfd_link_executable (info))
info->flags |= DF_STATIC_TLS;
/* Fall through */
cannot be used in shared libs. Don't error out for
sections we don't care about, such as debug sections or
non-constant sections. */
- if (info->shared
+ if (bfd_link_pic (info)
&& (sec->flags & SEC_ALLOC) != 0
&& (sec->flags & SEC_READONLY) != 0)
{
case R_X86_64_PC64:
case R_X86_64_64:
pointer:
- if (h != NULL && info->executable)
+ if (h != NULL && bfd_link_executable (info))
{
/* If this reloc is in a read-only section, we might
need a copy reloc. We can't check reliably at this
may need to keep relocations for symbols satisfied by a
dynamic library if we manage to avoid copy relocs for the
symbol. */
- if ((info->shared
+ if ((bfd_link_pic (info)
&& (sec->flags & SEC_ALLOC) != 0
&& (! IS_X86_64_PCREL_TYPE (r_type)
|| (h != NULL
|| h->root.type == bfd_link_hash_defweak
|| !h->def_regular))))
|| (ELIMINATE_COPY_RELOCS
- && !info->shared
+ && !bfd_link_pic (info)
&& (sec->flags & SEC_ALLOC) != 0
&& h != NULL
&& (h->root.type == bfd_link_hash_defweak
if (use_plt_got
&& h != NULL
&& h->plt.refcount > 0
- && ((info->flags & DF_BIND_NOW) || h->got.refcount > 0)
+ && (((info->flags & DF_BIND_NOW) && !h->pointer_equality_needed)
+ || h->got.refcount > 0)
&& htab->plt_got == NULL)
{
/* Create the GOT procedure linkage table. */
bfd_signed_vma *local_got_refcounts;
const Elf_Internal_Rela *rel, *relend;
- if (info->relocatable)
+ if (bfd_link_relocatable (info))
return TRUE;
htab = elf_x86_64_hash_table (info);
case R_X86_64_PC64:
case R_X86_64_SIZE32:
case R_X86_64_SIZE64:
- if (info->shared
+ if (bfd_link_pic (info)
&& (h == NULL || h->type != STT_GNU_IFUNC))
break;
/* Fall thru */
only references to the symbol are via the global offset table.
For such cases we need not do anything here; the relocations will
be handled correctly by relocate_section. */
- if (!info->executable)
+ if (!bfd_link_executable (info))
return TRUE;
/* If there are no references to this symbol that do not use the
{
bfd_boolean use_plt_got;
- if ((info->flags & DF_BIND_NOW))
+ if ((info->flags & DF_BIND_NOW) && !h->pointer_equality_needed)
{
/* Don't use the regular PLT for DF_BIND_NOW. */
h->plt.offset = (bfd_vma) -1;
return FALSE;
}
- if (info->shared
+ if (bfd_link_pic (info)
|| WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
{
asection *s = htab->elf.splt;
asection *bnd_s = htab->plt_bnd;
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 = plt_entry_size;
+
if (use_plt_got)
eh->plt_got.offset = got_s->size;
else
{
- /* If this is the first .plt entry, make room for the
- special first entry. */
- if (s->size == 0)
- s->size = plt_entry_size;
h->plt.offset = s->size;
if (bnd_s)
eh->plt_bnd.offset = bnd_s->size;
location in the .plt. This is required to make function
pointers compare as equal between the normal executable and
the shared library. */
- if (! info->shared
+ if (! bfd_link_pic (info)
&& !h->def_regular)
{
if (use_plt_got)
/* If R_X86_64_GOTTPOFF symbol is now local to the binary,
make it a R_X86_64_TPOFF32 requiring no GOT entry. */
if (h->got.refcount > 0
- && info->executable
+ && bfd_link_executable (info)
&& h->dynindx == -1
&& elf_x86_64_hash_entry (h)->tls_type == GOT_TLS_IE)
{
else if (! GOT_TLS_GDESC_P (tls_type)
&& (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
|| h->root.type != bfd_link_hash_undefweak)
- && (info->shared
+ && (bfd_link_pic (info)
|| WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
htab->elf.srelgot->size += bed->s->sizeof_rela;
if (GOT_TLS_GDESC_P (tls_type))
space for pc-relative relocs that have become local due to symbol
visibility changes. */
- if (info->shared)
+ if (bfd_link_pic (info))
{
/* Relocs that use pc_count are those that appear on a call
insn, or certain REL relocs that can generated via assembly.
}
/* For PIE, discard space for pc-relative relocs against
symbols which turn out to need copy relocs. */
- else if (info->executable
+ else if (bfd_link_executable (info)
&& (h->needs_copy || eh->needs_copy)
&& h->def_dynamic
&& !h->def_regular)
info->flags |= DF_TEXTREL;
- if ((info->warn_shared_textrel && info->shared)
+ if ((info->warn_shared_textrel && bfd_link_pic (info))
|| info->error_textrel)
info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
p->sec->owner, h->root.root.string,
bfd_boolean changed_contents;
bfd_boolean changed_relocs;
bfd_signed_vma *local_got_refcounts;
+ bfd_vma maxpagesize;
/* Don't even try to convert non-ELF outputs. */
if (!is_elf_hash_table (link_info->hash))
changed_contents = FALSE;
changed_relocs = FALSE;
local_got_refcounts = elf_local_got_refcounts (abfd);
+ maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
/* Get the section contents. */
if (elf_section_data (sec)->this_hdr.contents != NULL)
unsigned int r_symndx = htab->r_sym (irel->r_info);
unsigned int indx;
struct elf_link_hash_entry *h;
+ asection *tsec;
+ char symtype;
+ bfd_vma toff, roff;
+ enum {
+ none, local, global
+ } convert_mov_to_lea;
+ unsigned int opcode;
if (r_type != R_X86_64_GOTPCREL)
continue;
+ roff = irel->r_offset;
+
+ if (roff < 2)
+ continue;
+
+ opcode = bfd_get_8 (abfd, contents + roff - 2);
+
+ /* PR ld/18591: Don't convert R_X86_64_GOTPCREL relocation if it
+ isn't for mov instruction. */
+ if (opcode != 0x8b)
+ continue;
+
+ tsec = NULL;
+ convert_mov_to_lea = none;
+
/* Get the symbol referred to by the reloc. */
if (r_symndx < symtab_hdr->sh_info)
{
Elf_Internal_Sym *isym;
+ /* Silence older GCC warning. */
+ h = NULL;
+
isym = bfd_sym_from_r_symndx (&htab->sym_cache,
abfd, r_symndx);
- /* STT_GNU_IFUNC must keep R_X86_64_GOTPCREL relocation. */
- if (ELF_ST_TYPE (isym->st_info) != STT_GNU_IFUNC
- && irel->r_offset >= 2
- && bfd_get_8 (abfd, contents + irel->r_offset - 2) == 0x8b)
+ symtype = ELF_ST_TYPE (isym->st_info);
+
+ /* STT_GNU_IFUNC must keep R_X86_64_GOTPCREL relocation and
+ skip relocation against undefined symbols. */
+ if (symtype != STT_GNU_IFUNC && isym->st_shndx != SHN_UNDEF)
{
- bfd_put_8 (abfd, 0x8d, contents + irel->r_offset - 2);
- irel->r_info = htab->r_info (r_symndx, R_X86_64_PC32);
- if (local_got_refcounts != NULL
- && local_got_refcounts[r_symndx] > 0)
- local_got_refcounts[r_symndx] -= 1;
- changed_contents = TRUE;
- changed_relocs = TRUE;
+ if (isym->st_shndx == SHN_ABS)
+ tsec = bfd_abs_section_ptr;
+ else if (isym->st_shndx == SHN_COMMON)
+ tsec = bfd_com_section_ptr;
+ else if (isym->st_shndx == SHN_X86_64_LCOMMON)
+ tsec = &_bfd_elf_large_com_section;
+ else
+ tsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
+
+ toff = isym->st_value;
+ convert_mov_to_lea = local;
+ }
+ }
+ else
+ {
+ indx = r_symndx - symtab_hdr->sh_info;
+ h = elf_sym_hashes (abfd)[indx];
+ BFD_ASSERT (h != NULL);
+
+ 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 R_X86_64_GOTPCREL relocation. We also
+ avoid optimizing _DYNAMIC since ld.so may use its link-time
+ address. */
+ if (h->def_regular
+ && h->type != STT_GNU_IFUNC
+ && h != htab->elf.hdynamic
+ && SYMBOL_REFERENCES_LOCAL (link_info, h))
+ {
+ tsec = h->root.u.def.section;
+ toff = h->root.u.def.value;
+ symtype = h->type;
+ convert_mov_to_lea = global;
}
- continue;
}
- indx = r_symndx - symtab_hdr->sh_info;
- h = elf_sym_hashes (abfd)[indx];
- BFD_ASSERT (h != NULL);
+ if (convert_mov_to_lea == none)
+ continue;
- 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;
+ if (tsec->sec_info_type == SEC_INFO_TYPE_MERGE)
+ {
+ /* At this stage in linking, no SEC_MERGE symbol has been
+ adjusted, so all references to such symbols need to be
+ passed through _bfd_merged_section_offset. (Later, in
+ relocate_section, all SEC_MERGE symbols *except* for
+ section symbols have been adjusted.)
+
+ gas may reduce relocations against symbols in SEC_MERGE
+ sections to a relocation against the section symbol when
+ the original addend was zero. When the reloc is against
+ a section symbol we should include the addend in the
+ offset passed to _bfd_merged_section_offset, since the
+ location of interest is the original symbol. On the
+ other hand, an access to "sym+addend" where "sym" is not
+ a section symbol should not include the addend; Such an
+ access is presumed to be an offset from "sym"; The
+ location of interest is just "sym". */
+ if (symtype == STT_SECTION)
+ toff += irel->r_addend;
+
+ toff = _bfd_merged_section_offset (abfd, &tsec,
+ elf_section_data (tsec)->sec_info,
+ toff);
+
+ if (symtype != STT_SECTION)
+ toff += irel->r_addend;
+ }
+ else
+ toff += irel->r_addend;
- /* STT_GNU_IFUNC must keep R_X86_64_GOTPCREL relocation. We also
- avoid optimizing _DYNAMIC since ld.so may use its link-time
- address. */
- if (h->def_regular
- && h->type != STT_GNU_IFUNC
- && h != htab->elf.hdynamic
- && SYMBOL_REFERENCES_LOCAL (link_info, h)
- && irel->r_offset >= 2
- && bfd_get_8 (abfd, contents + irel->r_offset - 2) == 0x8b)
+ /* Don't convert if R_X86_64_PC32 relocation overflows. */
+ if (tsec->output_section == sec->output_section)
+ {
+ if ((toff - roff + 0x80000000) > 0xffffffff)
+ continue;
+ }
+ else
+ {
+ asection *asect;
+ bfd_size_type size;
+
+ /* At this point, we don't know the load addresses of TSEC
+ section nor SEC section. We estimate the distrance between
+ SEC and TSEC. */
+ size = 0;
+ for (asect = sec->output_section;
+ asect != NULL && asect != tsec->output_section;
+ asect = asect->next)
+ {
+ asection *i;
+ for (i = asect->output_section->map_head.s;
+ i != NULL;
+ i = i->map_head.s)
+ {
+ size = align_power (size, i->alignment_power);
+ size += i->size;
+ }
+ }
+
+ /* Don't convert R_X86_64_GOTPCREL if TSEC isn't placed after
+ SEC. */
+ if (asect == NULL)
+ continue;
+
+ /* Take PT_GNU_RELRO segment into account by adding
+ maxpagesize. */
+ if ((toff + size + maxpagesize - roff + 0x80000000)
+ > 0xffffffff)
+ continue;
+ }
+
+ bfd_put_8 (abfd, 0x8d, contents + roff - 2);
+ irel->r_info = htab->r_info (r_symndx, R_X86_64_PC32);
+ changed_contents = TRUE;
+ changed_relocs = TRUE;
+
+ if (convert_mov_to_lea == local)
+ {
+ if (local_got_refcounts != NULL
+ && local_got_refcounts[r_symndx] > 0)
+ local_got_refcounts[r_symndx] -= 1;
+ }
+ else
{
- bfd_put_8 (abfd, 0x8d, contents + irel->r_offset - 2);
- irel->r_info = htab->r_info (r_symndx, R_X86_64_PC32);
if (h->got.refcount > 0)
h->got.refcount -= 1;
- changed_contents = TRUE;
- changed_relocs = TRUE;
}
}
if (htab->elf.dynamic_sections_created)
{
/* Set the contents of the .interp section to the interpreter. */
- if (info->executable)
+ if (bfd_link_executable (info))
{
s = bfd_get_linker_section (dynobj, ".interp");
if (s == NULL)
&& (info->flags & DF_TEXTREL) == 0)
{
info->flags |= DF_TEXTREL;
- if ((info->warn_shared_textrel && info->shared)
+ if ((info->warn_shared_textrel && bfd_link_pic (info))
|| info->error_textrel)
info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
p->sec->owner, p->sec);
if (GOT_TLS_GD_P (*local_tls_type))
s->size += GOT_ENTRY_SIZE;
}
- if (info->shared
+ if (bfd_link_pic (info)
|| GOT_TLS_GD_ANY_P (*local_tls_type)
|| *local_tls_type == GOT_TLS_IE)
{
#define add_dynamic_entry(TAG, VAL) \
_bfd_elf_add_dynamic_entry (info, TAG, VAL)
- if (info->executable)
+ if (bfd_link_executable (info))
{
if (!add_dynamic_entry (DT_DEBUG, 0))
return FALSE;
if (htab->elf.splt->size != 0)
{
- if (!add_dynamic_entry (DT_PLTGOT, 0)
- || !add_dynamic_entry (DT_PLTRELSZ, 0)
- || !add_dynamic_entry (DT_PLTREL, DT_RELA)
- || !add_dynamic_entry (DT_JMPREL, 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_RELA)
+ || !add_dynamic_entry (DT_JMPREL, 0))
+ return FALSE;
+ }
+
if (htab->tlsdesc_plt
&& (!add_dynamic_entry (DT_TLSDESC_PLT, 0)
|| !add_dynamic_entry (DT_TLSDESC_GOT, 0)))
if ((info->flags & DF_TEXTREL) != 0)
{
+ if ((elf_tdata (output_bfd)->has_gnu_symbols
+ & elf_gnu_symbol_ifunc) == elf_gnu_symbol_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;
}
struct elf_x86_64_link_hash_table *htab;
struct bfd_link_hash_entry *base;
- if (!info->executable)
+ if (!bfd_link_executable (info))
return;
htab = elf_x86_64_hash_table (info);
st_size = sym->st_size;
/* Relocate against local STT_GNU_IFUNC symbol. */
- if (!info->relocatable
+ if (!bfd_link_relocatable (info)
&& ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
{
h = elf_x86_64_get_local_sym_hash (htab, input_bfd,
RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
rel, 1, relend, howto, 0, contents);
- if (info->relocatable)
+ if (bfd_link_relocatable (info))
continue;
if (rel->r_addend == 0 && !ABI_64_P (output_bfd))
bfd_vma plt_index;
const char *name;
- if ((input_section->flags & SEC_ALLOC) == 0
- || h->plt.offset == (bfd_vma) -1)
+ if ((input_section->flags & SEC_ALLOC) == 0)
+ {
+ /* Dynamic relocs are not propagated for SEC_DEBUGGING
+ sections because such sections are not SEC_ALLOC and
+ thus ld.so will not process them. */
+ if ((input_section->flags & SEC_DEBUGGING) != 0)
+ continue;
+ abort ();
+ }
+ else if (h->plt.offset == (bfd_vma) -1)
abort ();
/* STT_GNU_IFUNC symbol must go through PLT. */
return FALSE;
case R_X86_64_32S:
- if (info->shared)
+ if (bfd_link_pic (info))
abort ();
goto do_relocation;
/* Generate dynamic relcoation only when there is a
non-GOT reference in a shared object. */
- if (info->shared && h->non_got_ref)
+ if (bfd_link_pic (info) && h->non_got_ref)
{
Elf_Internal_Rela outrel;
asection *sreloc;
if (h->dynindx == -1
|| h->forced_local
- || info->executable)
+ || bfd_link_executable (info))
{
/* This symbol is resolved locally. */
outrel.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
dyn = htab->elf.dynamic_sections_created;
- if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
- || (info->shared
+ 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))
bfd_put_64 (output_bfd, relocation,
base_got->contents + off);
- if (info->shared)
+ if (bfd_link_pic (info))
{
asection *s;
Elf_Internal_Rela outrel;
symbol for shared library since it may not be local when
used as function address or with copy relocation. We also
need to make sure that a symbol is referenced locally. */
- if (info->shared && h)
+ if (bfd_link_pic (info) && h)
{
if (!h->def_regular)
{
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
- else if (!info->executable
+ else if (!bfd_link_executable (info)
&& !SYMBOL_REFERENCES_LOCAL (info, h)
&& (h->type == STT_FUNC
|| h->type == STT_OBJECT)
case R_X86_64_PC32_BND:
/* Don't complain about -fPIC if the symbol is undefined when
building executable. */
- if (info->shared
+ if (bfd_link_pic (info)
&& (input_section->flags & SEC_ALLOC) != 0
&& (input_section->flags & SEC_READONLY) != 0
&& h != NULL
- && !(info->executable
+ && !(bfd_link_executable (info)
&& h->root.type == bfd_link_hash_undefined))
{
bfd_boolean fail = FALSE;
defined locally or for a branch. */
fail = !h->def_regular && !branch;
}
- else if (!(info->executable
+ else if (!(bfd_link_executable (info)
&& (h->needs_copy || eh->needs_copy)))
{
/* Symbol doesn't need copy reloc and isn't referenced
/* Don't copy a pc-relative relocation into the output file
if the symbol needs copy reloc or the symbol is undefined
when building executable. */
- if ((info->shared
- && !(info->executable
+ if ((bfd_link_pic (info)
+ && !(bfd_link_executable (info)
&& h != NULL
&& (h->needs_copy
|| eh->needs_copy
&& r_type != R_X86_64_SIZE64)
|| ! SYMBOL_CALLS_LOCAL (info, h)))
|| (ELIMINATE_COPY_RELOCS
- && !info->shared
+ && !bfd_link_pic (info)
&& h != NULL
&& h->dynindx != -1
&& !h->non_got_ref
else if (h != NULL
&& h->dynindx != -1
&& (IS_X86_64_PCREL_TYPE (r_type)
- || ! info->shared
+ || ! bfd_link_pic (info)
|| ! SYMBOLIC_BIND (info, h)
|| ! h->def_regular))
{
break;
case R_X86_64_DTPOFF32:
- if (!info->executable|| (input_section->flags & SEC_CODE) == 0)
+ if (!bfd_link_executable (info)
+ || (input_section->flags & SEC_CODE) == 0)
relocation -= elf_x86_64_dtpoff_base (info);
else
relocation = elf_x86_64_tpoff (info, relocation);
case R_X86_64_TPOFF32:
case R_X86_64_TPOFF64:
- BFD_ASSERT (info->executable);
+ BFD_ASSERT (bfd_link_executable (info));
relocation = elf_x86_64_tpoff (info, relocation);
break;
/* This symbol has an entry in the procedure linkage table. Set
it up. */
if ((h->dynindx == -1
- && !((h->forced_local || info->executable)
+ && !((h->forced_local || bfd_link_executable (info))
&& h->def_regular
&& h->type == STT_GNU_IFUNC))
|| plt == NULL
+ gotplt->output_offset
+ got_offset);
if (h->dynindx == -1
- || ((info->executable
+ || ((bfd_link_executable (info)
|| ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
&& h->def_regular
&& h->type == STT_GNU_IFUNC))
if (h->def_regular
&& h->type == STT_GNU_IFUNC)
{
- if (info->shared)
+ if (bfd_link_pic (info))
{
/* Generate R_X86_64_GLOB_DAT. */
goto do_glob_dat;
return TRUE;
}
}
- else if (info->shared
+ else if (bfd_link_pic (info)
&& SYMBOL_REFERENCES_LOCAL (info, h))
{
if (!h->def_regular)
else
plt_sym_val[reloc_index] = plt->vma + plt_offset;
plt_offset += bed->plt_entry_size;
+
+ /* PR binutils/18437: Skip extra relocations in the .rela.plt
+ section. */
+ if (plt_offset >= plt->size)
+ break;
}
free (plt_contents);
return TRUE;
}
- if ((ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
- || ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE)
+ if (ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE
&& (abfd->flags & DYNAMIC) == 0
&& bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
- elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
+ elf_tdata (info->output_bfd)->has_gnu_symbols
+ |= elf_gnu_symbol_unique;
return TRUE;
}