/* IA-64 support for 64-bit ELF
- Copyright (C) 1998-2015 Free Software Foundation, Inc.
+ Copyright (C) 1998-2017 Free Software Foundation, Inc.
Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
This file is part of BFD, the Binary File Descriptor library.
one pass. */
*again = FALSE;
- if (link_info->relocatable)
+ if (bfd_link_relocatable (link_info))
(*link_info->callbacks->einfo)
(_("%P%F: --relax and -r may not be used together\n"));
if (strcmp (sec->output_section->name, ".init") == 0
|| strcmp (sec->output_section->name, ".fini") == 0)
{
- (*_bfd_error_handler)
- (_("%B: Can't relax br at 0x%lx in section `%A'. Please use brl or indirect branch."),
- sec->owner, sec, (unsigned long) roff);
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%B: Can't relax br at %#Lx in section `%A'."
+ " Please use brl or indirect branch."),
+ sec->owner, roff, sec);
bfd_set_error (bfd_error_bad_value);
goto error_return;
}
{
/* Resize .rela.got. */
ia64_info->root.srelgot->size = 0;
- if (link_info->shared
+ if (bfd_link_pic (link_info)
&& ia64_info->self_dtpmod_offset != (bfd_vma) -1)
ia64_info->root.srelgot->size += sizeof (ElfNN_External_Rela);
data.only_got = TRUE;
bfd_vma *valp)
{
if (sym->st_shndx == SHN_COMMON
- && !info->relocatable
+ && !bfd_link_relocatable (info)
&& sym->st_size <= elf_gp_size (abfd))
{
/* Common symbols less than or equal to -G nn bytes are
/* Copy down any references that we may have already seen to the
symbol which just became indirect. */
- dir->root.ref_dynamic |= ind->root.ref_dynamic;
+ if (dir->root.versioned != versioned_hidden)
+ dir->root.ref_dynamic |= ind->root.ref_dynamic;
dir->root.ref_regular |= ind->root.ref_regular;
dir->root.ref_regular_nonweak |= ind->root.ref_regular_nonweak;
dir->root.needs_plt |= ind->root.needs_plt;
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
- | (info->pie ? 0
- : SEC_READONLY)
+ | (bfd_link_pie (info)
+ ? 0 : SEC_READONLY)
| SEC_LINKER_CREATED));
if (!fptr
|| !bfd_set_section_alignment (abfd, fptr, 4))
ia64_info->fptr_sec = fptr;
- if (info->pie)
+ if (bfd_link_pie (info))
{
asection *fptr_rel;
fptr_rel = bfd_make_section_anyway_with_flags (dynobj, ".rela.opd",
unsigned long r_symndx;
bfd_boolean maybe_dynamic;
- if (info->relocatable)
+ if (bfd_link_relocatable (info))
return TRUE;
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
else
h = NULL;
+ if (h && UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
+ continue;
+
/* We can only get preliminary data on whether a symbol is
locally or externally defined, as not all of the input files
have yet been processed. Do something with what we know, as
this may help reduce memory usage and processing time later. */
- maybe_dynamic = (h && ((!info->executable
+ maybe_dynamic = (h && ((!bfd_link_executable (info)
&& (!SYMBOLIC_BIND (info, h)
|| info->unresolved_syms_in_shared_libs == RM_IGNORE))
|| !h->def_regular
{
case R_IA64_TPREL64MSB:
case R_IA64_TPREL64LSB:
- if (info->shared || maybe_dynamic)
+ if (bfd_link_pic (info) || maybe_dynamic)
need_entry = NEED_DYNREL;
break;
case R_IA64_LTOFF_TPREL22:
need_entry = NEED_TPREL;
- if (info->shared)
+ if (bfd_link_pic (info))
info->flags |= DF_STATIC_TLS;
break;
case R_IA64_DTPREL32LSB:
case R_IA64_DTPREL64MSB:
case R_IA64_DTPREL64LSB:
- if (info->shared || maybe_dynamic)
+ if (bfd_link_pic (info) || maybe_dynamic)
need_entry = NEED_DYNREL;
break;
case R_IA64_DTPMOD64MSB:
case R_IA64_DTPMOD64LSB:
- if (info->shared || maybe_dynamic)
+ if (bfd_link_pic (info) || maybe_dynamic)
need_entry = NEED_DYNREL;
break;
case R_IA64_FPTR32LSB:
case R_IA64_FPTR64MSB:
case R_IA64_FPTR64LSB:
- if (info->shared || h)
+ if (bfd_link_pic (info) || h)
need_entry = NEED_FPTR | NEED_DYNREL;
else
need_entry = NEED_FPTR;
case R_IA64_DIR64MSB:
case R_IA64_DIR64LSB:
/* Shared objects will always need at least a REL relocation. */
- if (info->shared || maybe_dynamic)
+ if (bfd_link_pic (info) || maybe_dynamic)
need_entry = NEED_DYNREL;
break;
case R_IA64_IPLTMSB:
case R_IA64_IPLTLSB:
/* Shared objects will always need at least a REL relocation. */
- if (info->shared || maybe_dynamic)
+ if (bfd_link_pic (info) || maybe_dynamic)
need_entry = NEED_DYNREL;
break;
/* PR15323, ref flags aren't set for references in the same
object. */
- h->root.non_ir_ref = 1;
+ h->root.non_ir_ref_regular = 1;
h->ref_regular = 1;
}
else
h = NULL;
+ if (h && UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
+ continue;
+
/* We can only get preliminary data on whether a symbol is
locally or externally defined, as not all of the input files
have yet been processed. Do something with what we know, as
this may help reduce memory usage and processing time later. */
- maybe_dynamic = (h && ((!info->executable
+ maybe_dynamic = (h && ((!bfd_link_executable (info)
&& (!SYMBOLIC_BIND (info, h)
|| info->unresolved_syms_in_shared_libs == RM_IGNORE))
|| !h->def_regular
{
case R_IA64_TPREL64MSB:
case R_IA64_TPREL64LSB:
- if (info->shared || maybe_dynamic)
+ if (bfd_link_pic (info) || maybe_dynamic)
need_entry = NEED_DYNREL;
dynrel_type = R_IA64_TPREL64LSB;
- if (info->shared)
+ if (bfd_link_pic (info))
info->flags |= DF_STATIC_TLS;
break;
case R_IA64_LTOFF_TPREL22:
need_entry = NEED_TPREL;
- if (info->shared)
+ if (bfd_link_pic (info))
info->flags |= DF_STATIC_TLS;
break;
case R_IA64_DTPREL32LSB:
case R_IA64_DTPREL64MSB:
case R_IA64_DTPREL64LSB:
- if (info->shared || maybe_dynamic)
+ if (bfd_link_pic (info) || maybe_dynamic)
need_entry = NEED_DYNREL;
dynrel_type = R_IA64_DTPRELNNLSB;
break;
case R_IA64_DTPMOD64MSB:
case R_IA64_DTPMOD64LSB:
- if (info->shared || maybe_dynamic)
+ if (bfd_link_pic (info) || maybe_dynamic)
need_entry = NEED_DYNREL;
dynrel_type = R_IA64_DTPMOD64LSB;
break;
case R_IA64_FPTR32LSB:
case R_IA64_FPTR64MSB:
case R_IA64_FPTR64LSB:
- if (info->shared || h)
+ if (bfd_link_pic (info) || h)
need_entry = NEED_FPTR | NEED_DYNREL;
else
need_entry = NEED_FPTR;
case R_IA64_DIR64MSB:
case R_IA64_DIR64LSB:
/* Shared objects will always need at least a REL relocation. */
- if (info->shared || maybe_dynamic)
+ if (bfd_link_pic (info) || maybe_dynamic)
need_entry = NEED_DYNREL;
dynrel_type = R_IA64_DIRNNLSB;
break;
case R_IA64_IPLTMSB:
case R_IA64_IPLTLSB:
/* Shared objects will always need at least a REL relocation. */
- if (info->shared || maybe_dynamic)
+ if (bfd_link_pic (info) || maybe_dynamic)
need_entry = NEED_DYNREL;
dynrel_type = R_IA64_IPLTLSB;
break;
/* FPTRs for shared libraries are allocated by the dynamic
linker. Make sure this local symbol will appear in the
dynamic symbol table. */
- if (!h && info->shared)
+ if (!h && bfd_link_pic (info))
{
if (! (bfd_elf_link_record_local_dynamic_symbol
(info, abfd, (long) r_symndx)))
|| h->root.type == bfd_link_hash_warning)
h = (struct elf_link_hash_entry *) h->root.u.i.link;
- if (!x->info->executable
+ if (!bfd_link_executable (x->info)
&& (!h
- || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
+ || (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
+ && !UNDEFWEAK_NO_DYNAMIC_RELOC (x->info, h))
|| (h->root.type != bfd_link_hash_undefweak
&& h->root.type != bfd_link_hash_undefined)))
{
/* Note that this can't be used in relation to FPTR relocs below. */
dynamic_symbol = elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0);
- shared = x->info->shared;
+ shared = bfd_link_pic (x->info);
resolved_zero = (dyn_i->h
- && ELF_ST_VISIBILITY (dyn_i->h->other)
- && dyn_i->h->root.type == bfd_link_hash_undefweak);
+ && UNDEFWEAK_NO_DYNAMIC_RELOC (x->info,
+ dyn_i->h));
/* Take care of the GOT and PLT relocations. */
&& dyn_i->h->dynindx != -1))
{
if (!dyn_i->want_ltoff_fptr
- || !x->info->pie
+ || !bfd_link_pie (x->info)
|| dyn_i->h == NULL
|| dyn_i->h->root.type != bfd_link_hash_undefweak)
ia64_info->root.srelgot->size += sizeof (ElfNN_External_Rela);
will be true only if we're actually allocating one statically
in the main executable. Position independent executables
need a relative reloc. */
- if (dyn_i->want_fptr && !x->info->pie)
+ if (dyn_i->want_fptr && !bfd_link_pie (x->info))
continue;
break;
case R_IA64_PCREL32LSB:
bfd *dynobj;
bfd_boolean relplt = FALSE;
- dynobj = elf_hash_table(info)->dynobj;
ia64_info = elfNN_ia64_hash_table (info);
if (ia64_info == NULL)
return FALSE;
+ dynobj = ia64_info->root.dynobj;
ia64_info->self_dtpmod_offset = (bfd_vma) -1;
BFD_ASSERT(dynobj != NULL);
data.info = info;
/* Set the contents of the .interp section to the interpreter. */
if (ia64_info->root.dynamic_sections_created
- && info->executable)
+ && bfd_link_executable (info) && !info->nointerp)
{
sec = bfd_get_linker_section (dynobj, ".interp");
BFD_ASSERT (sec != NULL);
/* If we've got a .plt, we need some extra memory for the dynamic
linker. We stuff these in .got.plt. */
- sec = bfd_get_linker_section (dynobj, ".got.plt");
- sec->size = 8 * PLT_RESERVED_WORDS;
+ ia64_info->root.sgotplt->size = 8 * PLT_RESERVED_WORDS;
}
/* Allocate the PLTOFF entries. */
/* Allocate space for the dynamic relocations that turned out to be
required. */
- if (info->shared && ia64_info->self_dtpmod_offset != (bfd_vma) -1)
+ if (bfd_link_pic (info) && ia64_info->self_dtpmod_offset != (bfd_vma) -1)
ia64_info->root.srelgot->size += sizeof (ElfNN_External_Rela);
data.only_got = FALSE;
elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_dynrel_entries, &data);
}
}
- if (elf_hash_table (info)->dynamic_sections_created)
+ if (ia64_info->root.dynamic_sections_created)
{
/* Add some entries to the .dynamic section. We fill in the values
later (in finish_dynamic_sections) but we must add the entries now
so that we get the correct size for the .dynamic section. */
- if (info->executable)
+ if (bfd_link_executable (info))
{
/* The DT_DEBUG entry is filled in by the dynamic linker and used
by the debugger. */
bfd_put_64 (abfd, value, got_sec->contents + got_offset);
/* Install a dynamic relocation if needed. */
- if (((info->shared
+ if (((bfd_link_pic (info)
&& (!dyn_i->h
- || ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT
+ || (ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT
+ && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, dyn_i->h))
|| dyn_i->h->root.type != bfd_link_hash_undefweak)
&& dyn_r_type != R_IA64_DTPREL32LSB
&& dyn_r_type != R_IA64_DTPREL64LSB)
&& (dyn_r_type == R_IA64_FPTR32LSB
|| dyn_r_type == R_IA64_FPTR64LSB)))
&& (!dyn_i->want_ltoff_fptr
- || !info->pie
+ || !bfd_link_pie (info)
|| !dyn_i->h
|| dyn_i->h->root.type != bfd_link_hash_undefweak))
{
/* Install dynamic relocations if needed. */
if (!is_plt
- && info->shared
+ && bfd_link_pic (info)
&& (!dyn_i->h
- || ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT
+ || (ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT
+ && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, dyn_i->h))
|| dyn_i->h->root.type != bfd_link_hash_undefweak))
{
unsigned int dyn_r_type;
if (max_short_vma - min_short_vma >= 0x400000)
{
overflow:
- (*_bfd_error_handler)
- (_("%s: short data segment overflowed (0x%lx >= 0x400000)"),
- bfd_get_filename (abfd),
- (unsigned long) (max_short_vma - min_short_vma));
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%B: short data segment overflowed (%#Lx >= 0x400000)"),
+ abfd, max_short_vma - min_short_vma);
return FALSE;
}
else if ((gp_val > min_short_vma
|| (gp_val < max_short_vma
&& max_short_vma - gp_val >= 0x200000))
{
- (*_bfd_error_handler)
- (_("%s: __gp does not cover short data segment"),
- bfd_get_filename (abfd));
+ _bfd_error_handler
+ (_("%B: __gp does not cover short data segment"), abfd);
return FALSE;
}
}
return FALSE;
/* Make sure we've got ourselves a nice fat __gp value. */
- if (!info->relocatable)
+ if (!bfd_link_relocatable (info))
{
bfd_vma gp_val;
struct elf_link_hash_entry *gp;
of the .IA_64.unwind section. Force this section to be relocated
into memory rather than written immediately to the output file. */
unwind_output_sec = NULL;
- if (!info->relocatable)
+ if (!bfd_link_relocatable (info))
{
asection *s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_unwind);
if (s)
return FALSE;
/* Infect various flags from the input section to the output section. */
- if (info->relocatable)
+ if (bfd_link_relocatable (info))
{
bfd_vma flags;
r_type = ELFNN_R_TYPE (rel->r_info);
if (r_type > R_IA64_MAX_RELOC_CODE)
{
- (*_bfd_error_handler)
- (_("%B: unknown relocation type %d"),
- input_bfd, (int) r_type);
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%B: unknown relocation type %d"), input_bfd, (int) r_type);
bfd_set_error (bfd_error_bad_value);
ret_val = FALSE;
continue;
sym_sec = local_sections[r_symndx];
msec = sym_sec;
value = _bfd_elf_rela_local_sym (output_bfd, sym, &msec, rel);
- if (!info->relocatable
+ if (!bfd_link_relocatable (info)
&& (sym_sec->flags & SEC_MERGE) != 0
&& ELF_ST_TYPE (sym->st_info) == STT_SECTION
&& sym_sec->sec_info_type == SEC_INFO_TYPE_MERGE)
if (h->root.type == bfd_link_hash_undefweak)
undef_weak_ref = TRUE;
- else if (warned || (ignored && info->executable))
+ else if (warned || (ignored && bfd_link_executable (info)))
continue;
}
RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
rel, 1, relend, howto, 0, contents);
- if (info->relocatable)
+ if (bfd_link_relocatable (info))
continue;
hit_addr = contents + rel->r_offset;
case R_IA64_DIR64MSB:
case R_IA64_DIR64LSB:
/* Install a dynamic relocation for this reloc. */
- if ((dynamic_symbol_p || info->shared)
+ if ((dynamic_symbol_p || bfd_link_pic (info))
+ && !(h && UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
&& r_symndx != STN_UNDEF
&& (input_section->flags & SEC_ALLOC) != 0)
{
case R_IA64_IMM64:
/* ??? People shouldn't be doing non-pic code in
shared libraries nor dynamic executables. */
- (*_bfd_error_handler)
+ _bfd_error_handler
+ /* xgettext:c-format */
(_("%B: non-pic code with imm relocation against dynamic symbol `%s'"),
input_bfd,
h ? h->root.root.string
case R_IA64_GPREL64LSB:
if (dynamic_symbol_p)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
+ /* xgettext:c-format */
(_("%B: @gprel relocation against dynamic symbol %s"),
input_bfd,
h ? h->root.root.string
if (!undef_weak_ref)
value = set_fptr_entry (output_bfd, info, dyn_i, value);
}
- if (!dyn_i->want_fptr || info->pie)
+ if (!dyn_i->want_fptr || bfd_link_pie (info))
{
long dynindx;
unsigned int dyn_r_type = r_type;
dynamic symbol table. */
/* ??? People shouldn't be doing non-pic code in
shared libraries. Hork. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: linking non-pic code in a position independent executable"),
input_bfd);
ret_val = FALSE;
const char *msg;
if (r_type == R_IA64_PCREL21BI)
+ /* xgettext:c-format */
msg = _("%B: @internal branch to dynamic symbol %s");
else if (r_type == R_IA64_PCREL21F || r_type == R_IA64_PCREL21M)
+ /* xgettext:c-format */
msg = _("%B: speculation fixup to dynamic symbol %s");
else
+ /* xgettext:c-format */
msg = _("%B: @pcrel relocation against dynamic symbol %s");
- (*_bfd_error_handler) (msg, input_bfd,
- h ? h->root.root.string
- : bfd_elf_sym_name (input_bfd,
- symtab_hdr,
- sym,
- sym_sec));
+ _bfd_error_handler (msg, input_bfd,
+ h ? h->root.root.string
+ : bfd_elf_sym_name (input_bfd,
+ symtab_hdr,
+ sym,
+ sym_sec));
ret_val = FALSE;
continue;
}
case R_IA64_IPLTMSB:
case R_IA64_IPLTLSB:
/* Install a dynamic relocation for this reloc. */
- if ((dynamic_symbol_p || info->shared)
+ if ((dynamic_symbol_p || bfd_link_pic (info))
&& (input_section->flags & SEC_ALLOC) != 0)
{
BFD_ASSERT (srel != NULL);
{
if (elf_hash_table (info)->tls_sec == NULL)
goto missing_tls_sec;
- if (!info->shared)
+ if (!bfd_link_pic (info))
value -= elfNN_ia64_tprel_base (info);
else
{
got_r_type = R_IA64_TPREL64LSB;
break;
case R_IA64_LTOFF_DTPMOD22:
- if (!dynamic_symbol_p && !info->shared)
+ if (!dynamic_symbol_p && !bfd_link_pic (info))
value = 1;
got_r_type = R_IA64_DTPMOD64LSB;
break;
else
name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
sym_sec);
- if (!(*info->callbacks->warning) (info, _("unsupported reloc"),
- name, input_bfd,
- input_section, rel->r_offset))
- return FALSE;
+ (*info->callbacks->warning) (info, _("unsupported reloc"),
+ name, input_bfd,
+ input_section, rel->r_offset);
ret_val = FALSE;
}
break;
case R_IA64_LTOFF_TPREL22:
case R_IA64_LTOFF_DTPMOD22:
case R_IA64_LTOFF_DTPREL22:
- (*_bfd_error_handler)
- (_("%B: missing TLS section for relocation %s against `%s' at 0x%lx in section `%A'."),
- input_bfd, input_section, howto->name, name,
- rel->r_offset);
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%B: missing TLS section for relocation %s against `%s'"
+ " at %#Lx in section `%A'."),
+ input_bfd, howto->name, name,
+ rel->r_offset, input_section);
break;
case R_IA64_PCREL21B:
/* Relaxtion is always performed for ELF output.
Overflow failures for those relocations mean
that the section is too big to relax. */
- (*_bfd_error_handler)
- (_("%B: Can't relax br (%s) to `%s' at 0x%lx in section `%A' with size 0x%lx (> 0x1000000)."),
- input_bfd, input_section, howto->name, name,
- rel->r_offset, input_section->size);
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%B: Can't relax br (%s) to `%s' at %#Lx"
+ " in section `%A' with size %#Lx (> 0x1000000)."),
+ input_bfd, howto->name, name, rel->r_offset,
+ input_section, input_section->size);
break;
}
+ /* Fall through. */
default:
- if (!(*info->callbacks->reloc_overflow) (info,
- &h->root,
- name,
- howto->name,
- (bfd_vma) 0,
- input_bfd,
- input_section,
- rel->r_offset))
- return FALSE;
+ (*info->callbacks->reloc_overflow) (info,
+ &h->root,
+ name,
+ howto->name,
+ (bfd_vma) 0,
+ input_bfd,
+ input_section,
+ rel->r_offset);
break;
}
dynobj = ia64_info->root.dynobj;
- if (elf_hash_table (info)->dynamic_sections_created)
+ if (ia64_info->root.dynamic_sections_created)
{
ElfNN_External_Dyn *dyncon, *dynconend;
asection *sdyn, *sgotplt;
bfd_vma gp_val;
sdyn = bfd_get_linker_section (dynobj, ".dynamic");
- sgotplt = bfd_get_linker_section (dynobj, ".got.plt");
+ sgotplt = ia64_info->root.sgotplt;
BFD_ASSERT (sdyn != NULL);
dyncon = (ElfNN_External_Dyn *) sdyn->contents;
dynconend = (ElfNN_External_Dyn *) (sdyn->contents + sdyn->size);
dyn.d_un.d_ptr = (sgotplt->output_section->vma
+ sgotplt->output_offset);
break;
-
- case DT_RELASZ:
- /* Do not have RELASZ include JMPREL. This makes things
- easier on ld.so. This is not what the rest of BFD set up. */
- dyn.d_un.d_val -= (ia64_info->minplt_entries
- * sizeof (ElfNN_External_Rela));
- break;
}
bfd_elfNN_swap_dyn_out (abfd, &dyn, dyncon);
/* Merge backend specific data from an object file to the output
object file when linking. */
static bfd_boolean
-elfNN_ia64_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
+elfNN_ia64_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
{
+ bfd *obfd = info->output_bfd;
flagword out_flags;
flagword in_flags;
bfd_boolean ok = TRUE;
if ((in_flags & EF_IA_64_TRAPNIL) != (out_flags & EF_IA_64_TRAPNIL))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: linking trap-on-NULL-dereference with non-trapping files"),
ibfd);
}
if ((in_flags & EF_IA_64_BE) != (out_flags & EF_IA_64_BE))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: linking big-endian files with little-endian files"),
ibfd);
}
if ((in_flags & EF_IA_64_ABI64) != (out_flags & EF_IA_64_ABI64))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: linking 64-bit files with 32-bit files"),
ibfd);
}
if ((in_flags & EF_IA_64_CONS_GP) != (out_flags & EF_IA_64_CONS_GP))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: linking constant-gp files with non-constant-gp files"),
ibfd);
if ((in_flags & EF_IA_64_NOFUNCDESC_CONS_GP)
!= (out_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("%B: linking auto-pic files with non-auto-pic files"),
ibfd);
#define elf_backend_fixup_symbol _bfd_elf_link_hash_fixup_symbol
#define elf_backend_reloc_type_class elfNN_ia64_reloc_type_class
#define elf_backend_rela_normal 1
+#define elf_backend_dtrel_excludes_plt 1
#define elf_backend_special_sections elfNN_ia64_special_sections
#define elf_backend_default_execstack 0