/* IA-64 support for 64-bit ELF
- Copyright (C) 1998-2017 Free Software Foundation, Inc.
+ Copyright (C) 1998-2021 Free Software Foundation, Inc.
Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
This file is part of BFD, the Binary File Descriptor library.
#include "elf/ia64.h"
#include "objalloc.h"
#include "hashtab.h"
-#include "bfd_stdint.h"
#include "elfxx-ia64.h"
#define ARCH_SIZE NN
#define LOG_SECTION_ALIGN 2
#endif
+#define is_ia64_elf(bfd) \
+ (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
+ && elf_object_id (bfd) == IA64_ELF_DATA)
+
typedef struct bfd_hash_entry *(*new_hash_entry_func)
(struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
int count;
/* Is this reloc against readonly section? */
- bfd_boolean reltext;
+ bool reltext;
} *reloc_entries;
/* TRUE when the section contents have been updated. */
asection *rel_pltoff_sec; /* Dynamic relocation section for same. */
bfd_size_type minplt_entries; /* Number of minplt entries. */
- unsigned reltext : 1; /* Are there relocs against readonly sections? */
unsigned self_dtpmod_done : 1;/* Has self DTPMOD entry been finished? */
bfd_vma self_dtpmod_offset; /* .got offset to self DTPMOD entry. */
/* There are maybe R_IA64_GPREL22 relocations, including those
{
struct bfd_link_info *info;
bfd_size_type ofs;
- bfd_boolean only_got;
+ bool only_got;
};
#define elfNN_ia64_hash_table(p) \
- (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
- == IA64_ELF_DATA ? ((struct elfNN_ia64_link_hash_table *) ((p)->hash)) : NULL)
+ ((is_elf_hash_table ((p)->hash) \
+ && elf_hash_table_id (elf_hash_table (p)) == IA64_ELF_DATA) \
+ ? (struct elfNN_ia64_link_hash_table *) (p)->hash : NULL)
static struct elfNN_ia64_dyn_sym_info * get_dyn_sym_info
(struct elfNN_ia64_link_hash_table *ia64_info,
struct elf_link_hash_entry *h,
- bfd *abfd, const Elf_Internal_Rela *rel, bfd_boolean create);
-static bfd_boolean elfNN_ia64_dynamic_symbol_p
+ bfd *abfd, const Elf_Internal_Rela *rel, bool create);
+static bool elfNN_ia64_dynamic_symbol_p
(struct elf_link_hash_entry *h, struct bfd_link_info *info, int);
-static bfd_boolean elfNN_ia64_choose_gp
- (bfd *abfd, struct bfd_link_info *info, bfd_boolean final);
+static bool elfNN_ia64_choose_gp
+ (bfd *abfd, struct bfd_link_info *info, bool final);
static void elfNN_ia64_dyn_sym_traverse
(struct elfNN_ia64_link_hash_table *ia64_info,
- bfd_boolean (*func) (struct elfNN_ia64_dyn_sym_info *, void *),
+ bool (*func) (struct elfNN_ia64_dyn_sym_info *, void *),
void * info);
-static bfd_boolean allocate_global_data_got
+static bool allocate_global_data_got
(struct elfNN_ia64_dyn_sym_info *dyn_i, void * data);
-static bfd_boolean allocate_global_fptr_got
+static bool allocate_global_fptr_got
(struct elfNN_ia64_dyn_sym_info *dyn_i, void * data);
-static bfd_boolean allocate_local_got
+static bool allocate_local_got
(struct elfNN_ia64_dyn_sym_info *dyn_i, void * data);
-static bfd_boolean elfNN_ia64_hpux_vec
+static bool elfNN_ia64_hpux_vec
(const bfd_target *vec);
-static bfd_boolean allocate_dynrel_entries
+static bool allocate_dynrel_entries
(struct elfNN_ia64_dyn_sym_info *dyn_i, void * data);
static asection *get_pltoff
(bfd *abfd, struct bfd_link_info *info,
/* Given a ELF reloc, return the matching HOWTO structure. */
-static void
+static bool
elfNN_ia64_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
arelent *bfd_reloc,
Elf_Internal_Rela *elf_reloc)
{
- bfd_reloc->howto
- = ia64_elf_lookup_howto ((unsigned int) ELFNN_R_TYPE (elf_reloc->r_info));
+ unsigned int r_type = ELF32_R_TYPE (elf_reloc->r_info);
+
+ bfd_reloc->howto = ia64_elf_lookup_howto (r_type);
+ if (bfd_reloc->howto == NULL)
+ {
+ /* xgettext:c-format */
+ _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
+ abfd, r_type);
+ bfd_set_error (bfd_error_bad_value);
+ return false;
+ }
+
+ return true;
}
\f
#define PLT_HEADER_SIZE (3 * 16)
static const bfd_byte plt_header[PLT_HEADER_SIZE] =
{
- 0x0b, 0x10, 0x00, 0x1c, 0x00, 0x21, /* [MMI] mov r2=r14;; */
- 0xe0, 0x00, 0x08, 0x00, 0x48, 0x00, /* addl r14=0,r2 */
- 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
- 0x0b, 0x80, 0x20, 0x1c, 0x18, 0x14, /* [MMI] ld8 r16=[r14],8;; */
- 0x10, 0x41, 0x38, 0x30, 0x28, 0x00, /* ld8 r17=[r14],8 */
- 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
- 0x11, 0x08, 0x00, 0x1c, 0x18, 0x10, /* [MIB] ld8 r1=[r14] */
- 0x60, 0x88, 0x04, 0x80, 0x03, 0x00, /* mov b6=r17 */
- 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
+ 0x0b, 0x10, 0x00, 0x1c, 0x00, 0x21, /* [MMI] mov r2=r14;; */
+ 0xe0, 0x00, 0x08, 0x00, 0x48, 0x00, /* addl r14=0,r2 */
+ 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
+ 0x0b, 0x80, 0x20, 0x1c, 0x18, 0x14, /* [MMI] ld8 r16=[r14],8;; */
+ 0x10, 0x41, 0x38, 0x30, 0x28, 0x00, /* ld8 r17=[r14],8 */
+ 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
+ 0x11, 0x08, 0x00, 0x1c, 0x18, 0x10, /* [MIB] ld8 r1=[r14] */
+ 0x60, 0x88, 0x04, 0x80, 0x03, 0x00, /* mov b6=r17 */
+ 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
};
static const bfd_byte plt_min_entry[PLT_MIN_ENTRY_SIZE] =
{
- 0x11, 0x78, 0x00, 0x00, 0x00, 0x24, /* [MIB] mov r15=0 */
- 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, /* nop.i 0x0 */
- 0x00, 0x00, 0x00, 0x40
/* br.few 0 <PLT0>;; */
+ 0x11, 0x78, 0x00, 0x00, 0x00, 0x24, /* [MIB] mov r15=0 */
+ 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, /* nop.i 0x0 */
+ 0x00, 0x00, 0x00, 0x40 /* br.few 0 <PLT0>;; */
};
static const bfd_byte plt_full_entry[PLT_FULL_ENTRY_SIZE] =
{
- 0x0b, 0x78, 0x00, 0x02, 0x00, 0x24, /* [MMI] addl r15=0,r1;; */
- 0x00, 0x41, 0x3c, 0x70, 0x29, 0xc0, /* ld8.acq r16=[r15],8*/
- 0x01, 0x08, 0x00, 0x84, /* mov r14=r1;; */
- 0x11, 0x08, 0x00, 0x1e, 0x18, 0x10, /* [MIB] ld8 r1=[r15] */
- 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
- 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
+ 0x0b, 0x78, 0x00, 0x02, 0x00, 0x24, /* [MMI] addl r15=0,r1;; */
+ 0x00, 0x41, 0x3c, 0x70, 0x29, 0xc0, /* ld8.acq r16=[r15],8*/
+ 0x01, 0x08, 0x00, 0x84, /* mov r14=r1;; */
+ 0x11, 0x08, 0x00, 0x1e, 0x18, 0x10, /* [MIB] ld8 r1=[r15] */
+ 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
+ 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
};
#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
static const bfd_byte oor_brl[16] =
{
- 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* brl.sptk.few tgt;; */
+ 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* brl.sptk.few tgt;; */
0x00, 0x00, 0x00, 0xc0
};
static const bfd_byte oor_ip[48] =
{
- 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, /* movl r15=0 */
+ 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, /* movl r15=0 */
0x01, 0x00, 0x00, 0x60,
- 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MII] nop.m 0 */
- 0x00, 0x01, 0x00, 0x60, 0x00, 0x00, /* mov r16=ip;; */
- 0xf2, 0x80, 0x00, 0x80, /* add r16=r15,r16;; */
- 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MIB] nop.m 0 */
- 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
- 0x60, 0x00, 0x80, 0x00 /* br b6;; */
+ 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MII] nop.m 0 */
+ 0x00, 0x01, 0x00, 0x60, 0x00, 0x00, /* mov r16=ip;; */
+ 0xf2, 0x80, 0x00, 0x80, /* add r16=r15,r16;; */
+ 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MIB] nop.m 0 */
+ 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
+ 0x60, 0x00, 0x80, 0x00 /* br b6;; */
};
static size_t oor_branch_size = sizeof (oor_brl);
}
}
-static bfd_boolean
+static bool
elfNN_ia64_relax_section (bfd *abfd, asection *sec,
struct bfd_link_info *link_info,
- bfd_boolean *again)
+ bool *again)
{
struct one_fixup
{
Elf_Internal_Sym *isymbuf = NULL;
struct elfNN_ia64_link_hash_table *ia64_info;
struct one_fixup *fixups = NULL;
- bfd_boolean changed_contents = FALSE;
- bfd_boolean changed_relocs = FALSE;
- bfd_boolean changed_got = FALSE;
- bfd_boolean skip_relax_pass_0 = TRUE;
- bfd_boolean skip_relax_pass_1 = TRUE;
+ bool changed_contents = false;
+ bool changed_relocs = false;
+ bool changed_got = false;
+ bool skip_relax_pass_0 = true;
+ bool skip_relax_pass_1 = true;
bfd_vma gp = 0;
/* Assume we're not going to change any sizes, and we'll only need
one pass. */
- *again = FALSE;
+ *again = false;
if (bfd_link_relocatable (link_info))
(*link_info->callbacks->einfo)
/* Don't even try to relax for non-ELF outputs. */
if (!is_elf_hash_table (link_info->hash))
- return FALSE;
+ return false;
/* Nothing to do if there are no relocations or there is no need for
the current pass. */
|| sec->reloc_count == 0
|| (link_info->relax_pass == 0 && sec->skip_relax_pass_0)
|| (link_info->relax_pass == 1 && sec->skip_relax_pass_1))
- return TRUE;
+ return true;
ia64_info = elfNN_ia64_hash_table (link_info);
if (ia64_info == NULL)
- return FALSE;
+ return false;
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
(abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
link_info->keep_memory));
if (internal_relocs == NULL)
- return FALSE;
+ return false;
irelend = internal_relocs + sec->reloc_count;
asection *tsec;
struct one_fixup *f;
bfd_size_type amt;
- bfd_boolean is_branch;
+ bool is_branch;
struct elfNN_ia64_dyn_sym_info *dyn_i;
char symtype;
/* In pass 1, all br relaxations are done. We can skip it. */
if (link_info->relax_pass == 1)
continue;
- skip_relax_pass_0 = FALSE;
- is_branch = TRUE;
+ skip_relax_pass_0 = false;
+ is_branch = true;
break;
case R_IA64_PCREL60B:
will increase the code size. Defer it to pass 1. */
if (link_info->relax_pass == 0)
{
- skip_relax_pass_1 = FALSE;
+ skip_relax_pass_1 = false;
continue;
}
- is_branch = TRUE;
+ is_branch = true;
break;
case R_IA64_GPREL22:
increase the code size. Defer it to pass 1. */
if (link_info->relax_pass == 0)
{
- skip_relax_pass_1 = FALSE;
+ skip_relax_pass_1 = false;
continue;
}
- is_branch = FALSE;
+ is_branch = false;
break;
default:
tsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
toff = isym->st_value;
- dyn_i = get_dyn_sym_info (ia64_info, NULL, abfd, irel, FALSE);
+ dyn_i = get_dyn_sym_info (ia64_info, NULL, abfd, irel, false);
symtype = ELF_ST_TYPE (isym->st_info);
}
else
|| h->root.type == bfd_link_hash_warning)
h = (struct elf_link_hash_entry *) h->root.u.i.link;
- dyn_i = get_dyn_sym_info (ia64_info, h, abfd, irel, FALSE);
+ dyn_i = get_dyn_sym_info (ia64_info, h, abfd, irel, false);
/* For branches to dynamic symbols, we're interested instead
in a branch to the PLT entry. */
1, change it to slot 2. */
if ((irel->r_offset & 3) == 1)
irel->r_offset += 1;
+
+ changed_contents = true;
+ changed_relocs = true;
}
continue;
/* Make the relocation offset point to slot 1. */
irel->r_offset = (irel->r_offset & ~((bfd_vma) 0x3)) + 1;
+
+ changed_contents = true;
+ changed_relocs = true;
continue;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: Can't relax br at 0x%lx in section `%A'."
- " Please use brl or indirect branch."),
- sec->owner, (unsigned long) roff, sec);
+ (_("%pB: can't relax br at %#" PRIx64 " in section `%pA';"
+ " please use brl or indirect branch"),
+ sec->owner, (uint64_t) roff, sec);
bfd_set_error (bfd_error_bad_value);
goto error_return;
}
!= bfd_reloc_ok)
goto error_return;
- changed_contents = TRUE;
- changed_relocs = TRUE;
+ changed_contents = true;
+ changed_relocs = true;
}
else
{
gp = _bfd_get_gp_value (obfd);
if (gp == 0)
{
- if (!elfNN_ia64_choose_gp (obfd, link_info, FALSE))
+ if (!elfNN_ia64_choose_gp (obfd, link_info, false))
goto error_return;
gp = _bfd_get_gp_value (obfd);
}
{
irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
R_IA64_GPREL22);
- changed_relocs = TRUE;
+ changed_relocs = true;
if (dyn_i->want_gotx)
{
dyn_i->want_gotx = 0;
{
ia64_elf_relax_ldxmov (contents, roff);
irel->r_info = ELFNN_R_INFO (0, R_IA64_NONE);
- changed_contents = TRUE;
- changed_relocs = TRUE;
+ changed_contents = true;
+ changed_relocs = true;
}
}
}
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;
+ data.only_got = true;
elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_dynrel_entries,
&data);
}
}
*again = changed_contents || changed_relocs;
- return TRUE;
+ return true;
error_return:
- if (isymbuf != NULL && (unsigned char *) isymbuf != symtab_hdr->contents)
+ if ((unsigned char *) isymbuf != symtab_hdr->contents)
free (isymbuf);
- if (contents != NULL
- && elf_section_data (sec)->this_hdr.contents != contents)
+ if (elf_section_data (sec)->this_hdr.contents != contents)
free (contents);
- if (internal_relocs != NULL
- && elf_section_data (sec)->relocs != internal_relocs)
+ if (elf_section_data (sec)->relocs != internal_relocs)
free (internal_relocs);
- return FALSE;
+ return false;
}
#undef skip_relax_pass_0
#undef skip_relax_pass_1
\f
/* Return TRUE if NAME is an unwind table section name. */
-static inline bfd_boolean
+static inline bool
is_unwind_section_name (bfd *abfd, const char *name)
{
if (elfNN_ia64_hpux_vec (abfd->xvec)
&& !strcmp (name, ELF_STRING_ia64_unwind_hdr))
- return FALSE;
+ return false;
- return ((CONST_STRNEQ (name, ELF_STRING_ia64_unwind)
- && ! CONST_STRNEQ (name, ELF_STRING_ia64_unwind_info))
- || CONST_STRNEQ (name, ELF_STRING_ia64_unwind_once));
+ return ((startswith (name, ELF_STRING_ia64_unwind)
+ && ! startswith (name, ELF_STRING_ia64_unwind_info))
+ || startswith (name, ELF_STRING_ia64_unwind_once));
}
/* Handle an IA-64 specific section when reading an object file. This
is called when bfd_section_from_shdr finds a section with an unknown
type. */
-static bfd_boolean
+static bool
elfNN_ia64_section_from_shdr (bfd *abfd,
Elf_Internal_Shdr *hdr,
const char *name,
case SHT_IA_64_EXT:
if (strcmp (name, ELF_STRING_ia64_archext) != 0)
- return FALSE;
+ return false;
break;
default:
- return FALSE;
+ return false;
}
if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
- return FALSE;
+ return false;
- return TRUE;
+ return true;
}
/* Convert IA-64 specific section flags to bfd internal section flags. */
/* ??? There is no bfd internal flag equivalent to the SHF_IA_64_NORECOV
flag. */
-static bfd_boolean
-elfNN_ia64_section_flags (flagword *flags,
- const Elf_Internal_Shdr *hdr)
+static bool
+elfNN_ia64_section_flags (const Elf_Internal_Shdr *hdr)
{
if (hdr->sh_flags & SHF_IA_64_SHORT)
- *flags |= SEC_SMALL_DATA;
+ hdr->bfd_section->flags |= SEC_SMALL_DATA;
- return TRUE;
+ return true;
}
/* Set the correct type for an IA-64 ELF section. We do this by the
section name, which is a hack, but ought to work. */
-static bfd_boolean
+static bool
elfNN_ia64_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr,
asection *sec)
{
const char *name;
- name = bfd_get_section_name (abfd, sec);
+ name = bfd_section_name (sec);
if (is_unwind_section_name (abfd, name))
{
if (elfNN_ia64_hpux_vec (abfd->xvec) && (sec->flags & SHF_TLS))
hdr->sh_flags |= SHF_IA_64_HP_TLS;
- return TRUE;
+ return true;
}
/* The final processing done just before writing out an IA-64 ELF
object file. */
-static void
-elfNN_ia64_final_write_processing (bfd *abfd,
- bfd_boolean linker ATTRIBUTE_UNUSED)
+static bool
+elfNN_ia64_final_write_processing (bfd *abfd)
{
Elf_Internal_Shdr *hdr;
asection *s;
flags |= EF_IA_64_ABI64;
elf_elfheader(abfd)->e_flags = flags;
- elf_flags_init (abfd) = TRUE;
+ elf_flags_init (abfd) = true;
}
+ return _bfd_elf_final_write_processing (abfd);
}
/* Hook called by the linker routine which adds symbols from an object
file. We use it to put .comm items in .sbss, and not .bss. */
-static bfd_boolean
+static bool
elfNN_ia64_add_symbol_hook (bfd *abfd,
struct bfd_link_info *info,
Elf_Internal_Sym *sym,
scomm = bfd_make_section_with_flags (abfd, ".scommon",
(SEC_ALLOC
| SEC_IS_COMMON
+ | SEC_SMALL_DATA
| SEC_LINKER_CREATED));
if (scomm == NULL)
- return FALSE;
+ return false;
}
*secp = scomm;
*valp = sym->st_size;
}
- return TRUE;
+ return true;
}
/* Return the number of additional phdrs we will need. */
return ret;
}
-static bfd_boolean
+static bool
elfNN_ia64_modify_segment_map (bfd *abfd,
struct bfd_link_info *info ATTRIBUTE_UNUSED)
{
m = ((struct elf_segment_map *)
bfd_zalloc (abfd, (bfd_size_type) sizeof *m));
if (m == NULL)
- return FALSE;
+ return false;
m->p_type = PT_IA_64_ARCHEXT;
m->count = 1;
m = ((struct elf_segment_map *)
bfd_zalloc (abfd, (bfd_size_type) sizeof *m));
if (m == NULL)
- return FALSE;
+ return false;
m->p_type = PT_IA_64_UNWIND;
m->count = 1;
}
}
- return TRUE;
+ return true;
}
/* Turn on PF_IA_64_NORECOV if needed. This involves traversing all of
the input sections for each output section in the segment and testing
for SHF_IA_64_NORECOV on each. */
-static bfd_boolean
-elfNN_ia64_modify_program_headers (bfd *abfd,
- struct bfd_link_info *info ATTRIBUTE_UNUSED)
+static bool
+elfNN_ia64_modify_headers (bfd *abfd, struct bfd_link_info *info)
{
struct elf_obj_tdata *tdata = elf_tdata (abfd);
struct elf_segment_map *m;
found:;
}
- return TRUE;
+ return _bfd_elf_modify_headers (abfd, info);
}
/* According to the Tahoe assembler spec, all labels starting with a
'.' are local. */
-static bfd_boolean
+static bool
elfNN_ia64_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
const char *name)
{
/* Should we do dynamic things to this symbol? */
-static bfd_boolean
+static bool
elfNN_ia64_dynamic_symbol_p (struct elf_link_hash_entry *h,
struct bfd_link_info *info, int r_type)
{
- bfd_boolean ignore_protected
+ bool ignore_protected
= ((r_type & 0xf8) == 0x40 /* FPTR relocs */
|| (r_type & 0xf8) == 0x50); /* LTOFF_FPTR relocs */
struct elfNN_ia64_dyn_sym_info *dyn_i;
unsigned int count;
- if (dir->info)
- free (dir->info);
+ free (dir->info);
dir->info = ind->info;
dir->count = ind->count;
static void
elfNN_ia64_hash_hide_symbol (struct bfd_link_info *info,
struct elf_link_hash_entry *xh,
- bfd_boolean force_local)
+ bool force_local)
{
struct elfNN_ia64_link_hash_entry *h;
struct elfNN_ia64_dyn_sym_info *dyn_i;
/* Free the global elfNN_ia64_dyn_sym_info array. */
-static bfd_boolean
-elfNN_ia64_global_dyn_info_free (void **xentry,
- void * unused ATTRIBUTE_UNUSED)
+static bool
+elfNN_ia64_global_dyn_info_free (struct elf_link_hash_entry *xentry,
+ void *unused ATTRIBUTE_UNUSED)
{
struct elfNN_ia64_link_hash_entry *entry
= (struct elfNN_ia64_link_hash_entry *) xentry;
- if (entry->info)
- {
- free (entry->info);
- entry->info = NULL;
- entry->count = 0;
- entry->sorted_count = 0;
- entry->size = 0;
- }
+ free (entry->info);
+ entry->info = NULL;
+ entry->count = 0;
+ entry->sorted_count = 0;
+ entry->size = 0;
- return TRUE;
+ return true;
}
/* Free the local elfNN_ia64_dyn_sym_info array. */
-static bfd_boolean
+static int
elfNN_ia64_local_dyn_info_free (void **slot,
void * unused ATTRIBUTE_UNUSED)
{
struct elfNN_ia64_local_hash_entry *entry
= (struct elfNN_ia64_local_hash_entry *) *slot;
- if (entry->info)
- {
- free (entry->info);
- entry->info = NULL;
- entry->count = 0;
- entry->sorted_count = 0;
- entry->size = 0;
- }
+ free (entry->info);
+ entry->info = NULL;
+ entry->count = 0;
+ entry->sorted_count = 0;
+ entry->size = 0;
- return TRUE;
+ return true;
}
/* Destroy IA-64 linker hash table. */
return NULL;
}
ret->root.root.hash_table_free = elfNN_ia64_link_hash_table_free;
+ ret->root.dt_pltgot_required = true;
return &ret->root.root;
}
struct elfNN_ia64_dyn_sym_traverse_data
{
- bfd_boolean (*func) (struct elfNN_ia64_dyn_sym_info *, void *);
+ bool (*func) (struct elfNN_ia64_dyn_sym_info *, void *);
void * data;
};
-static bfd_boolean
-elfNN_ia64_global_dyn_sym_thunk (struct bfd_hash_entry *xentry,
+static bool
+elfNN_ia64_global_dyn_sym_thunk (struct elf_link_hash_entry *xentry,
void * xdata)
{
struct elfNN_ia64_link_hash_entry *entry
count != 0;
count--, dyn_i++)
if (! (*data->func) (dyn_i, data->data))
- return FALSE;
- return TRUE;
+ return false;
+ return true;
}
-static bfd_boolean
+static int
elfNN_ia64_local_dyn_sym_thunk (void **slot, void * xdata)
{
struct elfNN_ia64_local_hash_entry *entry
count != 0;
count--, dyn_i++)
if (! (*data->func) (dyn_i, data->data))
- return FALSE;
- return TRUE;
+ return false;
+ return true;
}
static void
elfNN_ia64_dyn_sym_traverse (struct elfNN_ia64_link_hash_table *ia64_info,
- bfd_boolean (*func) (struct elfNN_ia64_dyn_sym_info *, void *),
+ bool (*func) (struct elfNN_ia64_dyn_sym_info *,
+ void *),
void * data)
{
struct elfNN_ia64_dyn_sym_traverse_data xdata;
elfNN_ia64_local_dyn_sym_thunk, &xdata);
}
\f
-static bfd_boolean
+static bool
elfNN_ia64_create_dynamic_sections (bfd *abfd,
struct bfd_link_info *info)
{
asection *s;
if (! _bfd_elf_create_dynamic_sections (abfd, info))
- return FALSE;
+ return false;
ia64_info = elfNN_ia64_hash_table (info);
if (ia64_info == NULL)
- return FALSE;
+ return false;
{
- flagword flags = bfd_get_section_flags (abfd, ia64_info->root.sgot);
- bfd_set_section_flags (abfd, ia64_info->root.sgot,
- SEC_SMALL_DATA | flags);
+ flagword flags = bfd_section_flags (ia64_info->root.sgot);
+ bfd_set_section_flags (ia64_info->root.sgot, SEC_SMALL_DATA | flags);
/* The .got section is always aligned at 8 bytes. */
- if (! bfd_set_section_alignment (abfd, ia64_info->root.sgot, 3))
- return FALSE;
+ if (!bfd_set_section_alignment (ia64_info->root.sgot, 3))
+ return false;
}
if (!get_pltoff (abfd, info, ia64_info))
- return FALSE;
+ return false;
s = bfd_make_section_anyway_with_flags (abfd, ".rela.IA_64.pltoff",
(SEC_ALLOC | SEC_LOAD
| SEC_LINKER_CREATED
| SEC_READONLY));
if (s == NULL
- || !bfd_set_section_alignment (abfd, s, LOG_SECTION_ALIGN))
- return FALSE;
+ || !bfd_set_section_alignment (s, LOG_SECTION_ALIGN))
+ return false;
ia64_info->rel_pltoff_sec = s;
- return TRUE;
+ return true;
}
/* Find and/or create a hash entry for local symbol. */
static struct elfNN_ia64_local_hash_entry *
get_local_sym_hash (struct elfNN_ia64_link_hash_table *ia64_info,
bfd *abfd, const Elf_Internal_Rela *rel,
- bfd_boolean create)
+ bool create)
{
struct elfNN_ia64_local_hash_entry e, *ret;
asection *sec = abfd->sections;
static struct elfNN_ia64_dyn_sym_info *
get_dyn_sym_info (struct elfNN_ia64_link_hash_table *ia64_info,
struct elf_link_hash_entry *h, bfd *abfd,
- const Elf_Internal_Rela *rel, bfd_boolean create)
+ const Elf_Internal_Rela *rel, bool create)
{
struct elfNN_ia64_dyn_sym_info **info_p, *info, *dyn_i, key;
unsigned int *count_p, *sorted_count_p, *size_p;
if (create)
{
/* When we create the array, we don't check for duplicates,
- except in the previously sorted section if one exists, and
+ except in the previously sorted section if one exists, and
against the last inserted entry. This allows insertions to
be fast. */
if (info)
key.addend = addend;
dyn_i = bsearch (&key, info, sorted_count,
sizeof (*info), addend_compare);
-
if (dyn_i)
- {
- return dyn_i;
- }
+ return dyn_i;
}
- /* Do a quick check for the last inserted entry. */
- dyn_i = info + count - 1;
- if (dyn_i->addend == addend)
+ if (count != 0)
{
- return dyn_i;
+ /* Do a quick check for the last inserted entry. */
+ dyn_i = info + count - 1;
+ if (dyn_i->addend == addend)
+ return dyn_i;
}
}
*size_p = size;
*info_p = info;
-has_space:
+ has_space:
/* Append the new one to the array. */
dyn_i = info + count;
memset (dyn_i, 0, sizeof (*dyn_i));
if (size != count)
{
amt = count * sizeof (*info);
- info = bfd_malloc (amt);
- if (info != NULL)
- {
- memcpy (info, *info_p, amt);
- free (*info_p);
- *size_p = count;
- *info_p = info;
- }
+ info = bfd_realloc (info, amt);
+ *size_p = count;
+ if (info == NULL && count != 0)
+ /* realloc should never fail since we are reducing size here,
+ but if it does use the old array. */
+ info = *info_p;
+ else
+ *info_p = info;
}
- key.addend = addend;
- dyn_i = bsearch (&key, info, count,
- sizeof (*info), addend_compare);
+ if (count == 0)
+ dyn_i = NULL;
+ else
+ {
+ key.addend = addend;
+ dyn_i = bsearch (&key, info, count, sizeof (*info), addend_compare);
+ }
}
return dyn_i;
got = ia64_info->root.sgot;
/* The .got section is always aligned at 8 bytes. */
- if (!bfd_set_section_alignment (abfd, got, 3))
+ if (!bfd_set_section_alignment (got, 3))
return NULL;
- flags = bfd_get_section_flags (abfd, got);
- if (! bfd_set_section_flags (abfd, got, SEC_SMALL_DATA | flags))
+ flags = bfd_section_flags (got);
+ if (!bfd_set_section_flags (got, SEC_SMALL_DATA | flags))
return NULL;
}
? 0 : SEC_READONLY)
| SEC_LINKER_CREATED));
if (!fptr
- || !bfd_set_section_alignment (abfd, fptr, 4))
+ || !bfd_set_section_alignment (fptr, 4))
{
BFD_ASSERT (0);
return NULL;
| SEC_LINKER_CREATED
| SEC_READONLY));
if (fptr_rel == NULL
- || !bfd_set_section_alignment (abfd, fptr_rel,
- LOG_SECTION_ALIGN))
+ || !bfd_set_section_alignment (fptr_rel, LOG_SECTION_ALIGN))
{
BFD_ASSERT (0);
return NULL;
| SEC_SMALL_DATA
| SEC_LINKER_CREATED));
if (!pltoff
- || !bfd_set_section_alignment (abfd, pltoff, 4))
+ || !bfd_set_section_alignment (pltoff, 4))
{
BFD_ASSERT (0);
return NULL;
static asection *
get_reloc_section (bfd *abfd,
struct elfNN_ia64_link_hash_table *ia64_info,
- asection *sec, bfd_boolean create)
+ asection *sec, bool create)
{
const char *srel_name;
asection *srel;
| SEC_LINKER_CREATED
| SEC_READONLY));
if (srel == NULL
- || !bfd_set_section_alignment (dynobj, srel,
- LOG_SECTION_ALIGN))
+ || !bfd_set_section_alignment (srel, LOG_SECTION_ALIGN))
return NULL;
}
return srel;
}
-static bfd_boolean
+static bool
count_dyn_reloc (bfd *abfd, struct elfNN_ia64_dyn_sym_info *dyn_i,
- asection *srel, int type, bfd_boolean reltext)
+ asection *srel, int type, bool reltext)
{
struct elfNN_ia64_dyn_reloc_entry *rent;
rent = ((struct elfNN_ia64_dyn_reloc_entry *)
bfd_alloc (abfd, (bfd_size_type) sizeof (*rent)));
if (!rent)
- return FALSE;
+ return false;
rent->next = dyn_i->reloc_entries;
rent->srel = srel;
rent->reltext = reltext;
rent->count++;
- return TRUE;
+ return true;
}
-static bfd_boolean
+static bool
elfNN_ia64_check_relocs (bfd *abfd, struct bfd_link_info *info,
asection *sec,
const Elf_Internal_Rela *relocs)
int need_entry;
struct elf_link_hash_entry *h;
unsigned long r_symndx;
- bfd_boolean maybe_dynamic;
+ bool maybe_dynamic;
if (bfd_link_relocatable (info))
- return TRUE;
+ return true;
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
ia64_info = elfNN_ia64_hash_table (info);
if (ia64_info == NULL)
- return FALSE;
+ return false;
got = fptr = srel = pltoff = NULL;
break;
case R_IA64_PCREL21B:
- case R_IA64_PCREL60B:
+ case R_IA64_PCREL60B:
/* Depending on where this symbol is defined, we may or may not
need a full plt entry. Only skip if we know we'll not need
the entry -- static or symbolic, and the symbol definition
abfd, 0, (bfd_vma) 0);
}
- if (get_dyn_sym_info (ia64_info, h, abfd, rel, TRUE) == NULL)
- return FALSE;
+ if (get_dyn_sym_info (ia64_info, h, abfd, rel, true) == NULL)
+ return false;
}
/* Now, we only do lookup without insertion, which is very fast
/* PR15323, ref flags aren't set for references in the same
object. */
- h->root.non_ir_ref = 1;
h->ref_regular = 1;
}
else
break;
case R_IA64_PCREL21B:
- case R_IA64_PCREL60B:
+ case R_IA64_PCREL60B:
/* Depending on where this symbol is defined, we may or may not
need a full plt entry. Only skip if we know we'll not need
the entry -- static or symbolic, and the symbol definition
if (!need_entry)
continue;
- dyn_i = get_dyn_sym_info (ia64_info, h, abfd, rel, FALSE);
+ dyn_i = get_dyn_sym_info (ia64_info, h, abfd, rel, false);
/* Record whether or not this is a local symbol. */
dyn_i->h = h;
{
got = get_got (abfd, info, ia64_info);
if (!got)
- return FALSE;
+ return false;
}
if (need_entry & NEED_GOT)
dyn_i->want_got = 1;
{
fptr = get_fptr (abfd, info, ia64_info);
if (!fptr)
- return FALSE;
+ return false;
}
/* FPTRs for shared libraries are allocated by the dynamic
{
if (! (bfd_elf_link_record_local_dynamic_symbol
(info, abfd, (long) r_symndx)))
- return FALSE;
+ return false;
}
dyn_i->want_fptr = 1;
dyn_i->want_ltoff_fptr = 1;
if (need_entry & (NEED_MIN_PLT | NEED_FULL_PLT))
{
- if (!ia64_info->root.dynobj)
+ if (!ia64_info->root.dynobj)
ia64_info->root.dynobj = abfd;
h->needs_plt = 1;
dyn_i->want_plt = 1;
{
pltoff = get_pltoff (abfd, info, ia64_info);
if (!pltoff)
- return FALSE;
+ return false;
}
dyn_i->want_pltoff = 1;
{
if (!srel)
{
- srel = get_reloc_section (abfd, ia64_info, sec, TRUE);
+ srel = get_reloc_section (abfd, ia64_info, sec, true);
if (!srel)
- return FALSE;
+ return false;
}
if (!count_dyn_reloc (abfd, dyn_i, srel, dynrel_type,
(sec->flags & SEC_READONLY) != 0))
- return FALSE;
+ return false;
}
}
- return TRUE;
+ return true;
}
/* For cleanliness, and potentially faster dynamic loading, allocate
external GOT entries first. */
-static bfd_boolean
+static bool
allocate_global_data_got (struct elfNN_ia64_dyn_sym_info *dyn_i,
void * data)
{
ia64_info = elfNN_ia64_hash_table (x->info);
if (ia64_info == NULL)
- return FALSE;
+ return false;
if (ia64_info->self_dtpmod_offset == (bfd_vma) -1)
{
dyn_i->dtprel_offset = x->ofs;
x->ofs += 8;
}
- return TRUE;
+ return true;
}
/* Next, allocate all the GOT entries used by LTOFF_FPTR relocs. */
-static bfd_boolean
+static bool
allocate_global_fptr_got (struct elfNN_ia64_dyn_sym_info *dyn_i,
void * data)
{
dyn_i->got_offset = x->ofs;
x->ofs += 8;
}
- return TRUE;
+ return true;
}
/* Lastly, allocate all the GOT entries for local data. */
-static bfd_boolean
+static bool
allocate_local_got (struct elfNN_ia64_dyn_sym_info *dyn_i,
void * data)
{
dyn_i->got_offset = x->ofs;
x->ofs += 8;
}
- return TRUE;
+ return true;
}
/* Search for the index of a global symbol in it's defining object file. */
/* Allocate function descriptors. We can do these for every function
in a main executable that is not exported. */
-static bfd_boolean
+static bool
allocate_fptr (struct elfNN_ia64_dyn_sym_info *dyn_i, void * data)
{
struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
if (!bfd_elf_link_record_local_dynamic_symbol
(x->info, h->root.u.def.section->owner,
global_sym_index (h)))
- return FALSE;
+ return false;
}
dyn_i->want_fptr = 0;
else
dyn_i->want_fptr = 0;
}
- return TRUE;
+ return true;
}
/* Allocate all the minimal PLT entries. */
-static bfd_boolean
+static bool
allocate_plt_entries (struct elfNN_ia64_dyn_sym_info *dyn_i,
void * data)
{
dyn_i->want_plt2 = 0;
}
}
- return TRUE;
+ return true;
}
/* Allocate all the full PLT entries. */
-static bfd_boolean
+static bool
allocate_plt2_entries (struct elfNN_ia64_dyn_sym_info *dyn_i,
void * data)
{
h = (struct elf_link_hash_entry *) h->root.u.i.link;
dyn_i->h->plt.offset = ofs;
}
- return TRUE;
+ return true;
}
/* Allocate all the PLTOFF entries requested by relocations and
because the latter are not necessarily addressable by the GP.
??? Relaxation might be able to determine that they are. */
-static bfd_boolean
+static bool
allocate_pltoff_entries (struct elfNN_ia64_dyn_sym_info *dyn_i,
void * data)
{
dyn_i->pltoff_offset = x->ofs;
x->ofs += 16;
}
- return TRUE;
+ return true;
}
/* Allocate dynamic relocations for those symbols that turned out
to be dynamic. */
-static bfd_boolean
+static bool
allocate_dynrel_entries (struct elfNN_ia64_dyn_sym_info *dyn_i,
void * data)
{
struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
struct elfNN_ia64_link_hash_table *ia64_info;
struct elfNN_ia64_dyn_reloc_entry *rent;
- bfd_boolean dynamic_symbol, shared, resolved_zero;
+ bool dynamic_symbol, shared, resolved_zero;
ia64_info = elfNN_ia64_hash_table (x->info);
if (ia64_info == NULL)
- return FALSE;
+ return false;
/* 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);
ia64_info->root.srelgot->size += sizeof (ElfNN_External_Rela);
if (x->only_got)
- return TRUE;
+ return true;
if (ia64_info->rel_fptr_sec && dyn_i->want_fptr)
{
abort ();
}
if (rent->reltext)
- ia64_info->reltext = 1;
+ x->info->flags |= DF_TEXTREL;
rent->srel->size += sizeof (ElfNN_External_Rela) * count;
}
- return TRUE;
+ return true;
}
-static bfd_boolean
+static bool
elfNN_ia64_adjust_dynamic_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
struct elf_link_hash_entry *h)
{
/* If this is a weak symbol, and there is a real definition, the
processor independent code will have arranged for us to see the
real definition first, and we can just use the same value. */
- if (h->u.weakdef != NULL)
+ if (h->is_weakalias)
{
- BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
- || h->u.weakdef->root.type == bfd_link_hash_defweak);
- h->root.u.def.section = h->u.weakdef->root.u.def.section;
- h->root.u.def.value = h->u.weakdef->root.u.def.value;
- return TRUE;
+ struct elf_link_hash_entry *def = weakdef (h);
+ BFD_ASSERT (def->root.type == bfd_link_hash_defined);
+ h->root.u.def.section = def->root.u.def.section;
+ h->root.u.def.value = def->root.u.def.value;
+ return true;
}
/* If this is a reference to a symbol defined by a dynamic object which
But IA-64 code is canonically PIC, so as a rule we can avoid this sort
of hackery. */
- return TRUE;
+ return true;
}
-static bfd_boolean
+static bool
elfNN_ia64_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
struct bfd_link_info *info)
{
struct elfNN_ia64_link_hash_table *ia64_info;
asection *sec;
bfd *dynobj;
- bfd_boolean relplt = FALSE;
ia64_info = elfNN_ia64_hash_table (info);
if (ia64_info == NULL)
- return FALSE;
+ return false;
dynobj = ia64_info->root.dynobj;
ia64_info->self_dtpmod_offset = (bfd_vma) -1;
BFD_ASSERT(dynobj != NULL);
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;
+ data.only_got = false;
elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_dynrel_entries, &data);
}
Allocate memory for them. */
for (sec = dynobj->sections; sec != NULL; sec = sec->next)
{
- bfd_boolean strip;
+ bool strip;
if (!(sec->flags & SEC_LINKER_CREATED))
continue;
strip = (sec->size == 0);
if (sec == ia64_info->root.sgot)
- strip = FALSE;
+ strip = false;
else if (sec == ia64_info->root.srelgot)
{
if (strip)
ia64_info->rel_pltoff_sec = NULL;
else
{
- relplt = TRUE;
+ ia64_info->root.dt_jmprel_required = true;
/* We use the reloc_count field as a counter if we need to
copy relocs into the output file. */
sec->reloc_count = 0;
/* It's OK to base decisions on the section name, because none
of the dynobj section names depend upon the input files. */
- name = bfd_get_section_name (dynobj, sec);
+ name = bfd_section_name (sec);
if (strcmp (name, ".got.plt") == 0)
- strip = FALSE;
- else if (CONST_STRNEQ (name, ".rel"))
+ strip = false;
+ else if (startswith (name, ".rel"))
{
if (!strip)
{
/* Allocate memory for the section contents. */
sec->contents = (bfd_byte *) bfd_zalloc (dynobj, sec->size);
if (sec->contents == NULL && sec->size != 0)
- return FALSE;
+ return false;
}
}
later (in finish_dynamic_sections) but we must add the entries now
so that we get the correct size for the .dynamic section. */
- if (bfd_link_executable (info))
- {
- /* 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 (!add_dynamic_entry (DT_DEBUG, 0))
- return FALSE;
- }
+ if (!_bfd_elf_add_dynamic_tags (output_bfd, info, true))
+ return false;
if (!add_dynamic_entry (DT_IA_64_PLT_RESERVE, 0))
- return FALSE;
- if (!add_dynamic_entry (DT_PLTGOT, 0))
- return FALSE;
-
- if (relplt)
- {
- if (!add_dynamic_entry (DT_PLTRELSZ, 0)
- || !add_dynamic_entry (DT_PLTREL, DT_RELA)
- || !add_dynamic_entry (DT_JMPREL, 0))
- return FALSE;
- }
-
- if (!add_dynamic_entry (DT_RELA, 0)
- || !add_dynamic_entry (DT_RELASZ, 0)
- || !add_dynamic_entry (DT_RELAENT, sizeof (ElfNN_External_Rela)))
- return FALSE;
-
- if (ia64_info->reltext)
- {
- if (!add_dynamic_entry (DT_TEXTREL, 0))
- return FALSE;
- info->flags |= DF_TEXTREL;
- }
+ return false;
}
/* ??? Perhaps force __gp local. */
- return TRUE;
+ return true;
}
static void
{
struct elfNN_ia64_link_hash_table *ia64_info;
asection *got_sec;
- bfd_boolean done;
+ bool done;
bfd_vma got_offset;
ia64_info = elfNN_ia64_hash_table (info);
{
case R_IA64_TPREL64LSB:
done = dyn_i->tprel_done;
- dyn_i->tprel_done = TRUE;
+ dyn_i->tprel_done = true;
got_offset = dyn_i->tprel_offset;
break;
case R_IA64_DTPMOD64LSB:
if (dyn_i->dtpmod_offset != ia64_info->self_dtpmod_offset)
{
done = dyn_i->dtpmod_done;
- dyn_i->dtpmod_done = TRUE;
+ dyn_i->dtpmod_done = true;
}
else
{
done = ia64_info->self_dtpmod_done;
- ia64_info->self_dtpmod_done = TRUE;
+ ia64_info->self_dtpmod_done = true;
dynindx = 0;
}
got_offset = dyn_i->dtpmod_offset;
case R_IA64_DTPREL32LSB:
case R_IA64_DTPREL64LSB:
done = dyn_i->dtprel_done;
- dyn_i->dtprel_done = TRUE;
+ dyn_i->dtprel_done = true;
got_offset = dyn_i->dtprel_offset;
break;
default:
done = dyn_i->got_done;
- dyn_i->got_done = TRUE;
+ dyn_i->got_done = true;
got_offset = dyn_i->got_offset;
break;
}
|| dyn_i->h->root.type != bfd_link_hash_undefweak)
&& dyn_r_type != R_IA64_DTPREL32LSB
&& dyn_r_type != R_IA64_DTPREL64LSB)
- || elfNN_ia64_dynamic_symbol_p (dyn_i->h, info, dyn_r_type)
+ || elfNN_ia64_dynamic_symbol_p (dyn_i->h, info, dyn_r_type)
|| (dynindx != -1
&& (dyn_r_type == R_IA64_FPTR32LSB
|| dyn_r_type == R_IA64_FPTR64LSB)))
dyn_r_type = R_IA64_DTPREL64MSB;
break;
default:
- BFD_ASSERT (FALSE);
+ BFD_ASSERT (false);
break;
}
}
static bfd_vma
set_pltoff_entry (bfd *abfd, struct bfd_link_info *info,
struct elfNN_ia64_dyn_sym_info *dyn_i,
- bfd_vma value, bfd_boolean is_plt)
+ bfd_vma value, bool is_plt)
{
struct elfNN_ia64_link_hash_table *ia64_info;
asection *pltoff_sec;
}
/* Make sure we've got ourselves a nice fat __gp value. */
-static bfd_boolean
-elfNN_ia64_choose_gp (bfd *abfd, struct bfd_link_info *info, bfd_boolean final)
+static bool
+elfNN_ia64_choose_gp (bfd *abfd, struct bfd_link_info *info, bool final)
{
bfd_vma min_vma = (bfd_vma) -1, max_vma = 0;
bfd_vma min_short_vma = min_vma, max_short_vma = 0;
ia64_info = elfNN_ia64_hash_table (info);
if (ia64_info == NULL)
- return FALSE;
+ return false;
/* Find the min and max vma of all sections marked short. Also collect
min and max vma of any type, for use in selecting a nice gp. */
}
/* See if the user wants to force a value. */
- gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", FALSE,
- FALSE, FALSE);
+ gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", false,
+ false, false);
if (gp
&& (gp->root.type == bfd_link_hash_defined
{
if (max_short_vma - min_short_vma >= 0x400000)
{
-overflow:
+ overflow:
_bfd_error_handler
/* xgettext:c-format */
- (_("%s: short data segment overflowed (0x%lx >= 0x400000)"),
- bfd_get_filename (abfd),
- (unsigned long) (max_short_vma - min_short_vma));
- return FALSE;
+ (_("%pB: short data segment overflowed (%#" PRIx64 " >= 0x400000)"),
+ abfd, (uint64_t) (max_short_vma - min_short_vma));
+ return false;
}
else if ((gp_val > min_short_vma
&& gp_val - min_short_vma > 0x200000)
&& max_short_vma - gp_val >= 0x200000))
{
_bfd_error_handler
- (_("%s: __gp does not cover short data segment"),
- bfd_get_filename (abfd));
- return FALSE;
+ (_("%pB: __gp does not cover short data segment"), abfd);
+ return false;
}
}
_bfd_set_gp_value (abfd, gp_val);
- return TRUE;
+ return true;
}
-static bfd_boolean
+static bool
elfNN_ia64_final_link (bfd *abfd, struct bfd_link_info *info)
{
struct elfNN_ia64_link_hash_table *ia64_info;
ia64_info = elfNN_ia64_hash_table (info);
if (ia64_info == NULL)
- return FALSE;
+ return false;
/* Make sure we've got ourselves a nice fat __gp value. */
if (!bfd_link_relocatable (info))
/* We assume after gp is set, section size will only decrease. We
need to adjust gp for it. */
_bfd_set_gp_value (abfd, 0);
- if (! elfNN_ia64_choose_gp (abfd, info, TRUE))
- return FALSE;
+ if (! elfNN_ia64_choose_gp (abfd, info, true))
+ return false;
gp_val = _bfd_get_gp_value (abfd);
- gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", FALSE,
- FALSE, FALSE);
+ gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", false,
+ false, false);
if (gp)
{
gp->root.type = bfd_link_hash_defined;
unwind_output_sec->contents
= bfd_malloc (unwind_output_sec->size);
if (unwind_output_sec->contents == NULL)
- return FALSE;
+ return false;
}
}
/* Invoke the regular ELF backend linker to do all the work. */
if (!bfd_elf_final_link (abfd, info))
- return FALSE;
+ return false;
if (unwind_output_sec)
{
if (! bfd_set_section_contents (abfd, unwind_output_sec,
unwind_output_sec->contents, (bfd_vma) 0,
unwind_output_sec->size))
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
-static bfd_boolean
+static int
elfNN_ia64_relocate_section (bfd *output_bfd,
struct bfd_link_info *info,
bfd *input_bfd,
Elf_Internal_Rela *rel;
Elf_Internal_Rela *relend;
asection *srel;
- bfd_boolean ret_val = TRUE; /* for non-fatal errors */
+ bool ret_val = true; /* for non-fatal errors */
bfd_vma gp_val;
symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
ia64_info = elfNN_ia64_hash_table (info);
if (ia64_info == NULL)
- return FALSE;
+ return false;
/* Infect various flags from the input section to the output section. */
if (bfd_link_relocatable (info))
}
gp_val = _bfd_get_gp_value (output_bfd);
- srel = get_reloc_section (input_bfd, ia64_info, input_section, FALSE);
+ srel = get_reloc_section (input_bfd, ia64_info, input_section, false);
rel = relocs;
relend = relocs + input_section->reloc_count;
bfd_vma value;
asection *sym_sec;
bfd_byte *hit_addr;
- bfd_boolean dynamic_symbol_p;
- bfd_boolean undef_weak_ref;
+ bool dynamic_symbol_p;
+ bool undef_weak_ref;
r_type = ELFNN_R_TYPE (rel->r_info);
if (r_type > R_IA64_MAX_RELOC_CODE)
{
- _bfd_error_handler
- /* xgettext:c-format */
- (_("%B: unknown relocation type %d"),
- input_bfd, (int) r_type);
+ /* xgettext:c-format */
+ _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
+ input_bfd, (int) r_type);
bfd_set_error (bfd_error_bad_value);
- ret_val = FALSE;
+ ret_val = false;
continue;
}
howto = ia64_elf_lookup_howto (r_type);
+ if (howto == NULL)
+ {
+ ret_val = false;
+ continue;
+ }
+
r_symndx = ELFNN_R_SYM (rel->r_info);
h = NULL;
sym = NULL;
sym_sec = NULL;
- undef_weak_ref = FALSE;
+ undef_weak_ref = false;
if (r_symndx < symtab_hdr->sh_info)
{
{
struct elfNN_ia64_local_hash_entry *loc_h;
- loc_h = get_local_sym_hash (ia64_info, input_bfd, rel, FALSE);
+ loc_h = get_local_sym_hash (ia64_info, input_bfd, rel, false);
if (loc_h && ! loc_h->sec_merge_done)
{
struct elfNN_ia64_dyn_sym_info *dynent;
}
else
{
- bfd_boolean unresolved_reloc;
- bfd_boolean warned, ignored;
+ bool unresolved_reloc;
+ bool warned, ignored;
struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
unresolved_reloc, warned, ignored);
if (h->root.type == bfd_link_hash_undefweak)
- undef_weak_ref = TRUE;
+ undef_weak_ref = true;
else if (warned || (ignored && bfd_link_executable (info)))
continue;
}
shared libraries nor dynamic executables. */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: non-pic code with imm relocation against dynamic symbol `%s'"),
+ (_("%pB: non-pic code with imm relocation against dynamic symbol `%s'"),
input_bfd,
h ? h->root.root.string
: bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
sym_sec));
- ret_val = FALSE;
+ ret_val = false;
continue;
default:
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: @gprel relocation against dynamic symbol %s"),
+ (_("%pB: @gprel relocation against dynamic symbol %s"),
input_bfd,
h ? h->root.root.string
: bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
sym_sec));
- ret_val = FALSE;
+ ret_val = false;
continue;
}
value -= gp_val;
case R_IA64_LTOFF22:
case R_IA64_LTOFF22X:
case R_IA64_LTOFF64I:
- dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
+ dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false);
value = set_got_entry (input_bfd, info, dyn_i, (h ? h->dynindx : -1),
rel->r_addend, value, R_IA64_DIRNNLSB);
value -= gp_val;
case R_IA64_PLTOFF64I:
case R_IA64_PLTOFF64MSB:
case R_IA64_PLTOFF64LSB:
- dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
- value = set_pltoff_entry (output_bfd, info, dyn_i, value, FALSE);
+ dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false);
+ value = set_pltoff_entry (output_bfd, info, dyn_i, value, false);
value -= gp_val;
r = ia64_elf_install_value (hit_addr, value, r_type);
break;
case R_IA64_FPTR32LSB:
case R_IA64_FPTR64MSB:
case R_IA64_FPTR64LSB:
- dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
+ dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false);
if (dyn_i->want_fptr)
{
if (!undef_weak_ref)
/* ??? People shouldn't be doing non-pic code in
shared libraries. Hork. */
_bfd_error_handler
- (_("%B: linking non-pic code in a position independent executable"),
+ (_("%pB: linking non-pic code in a position independent executable"),
input_bfd);
- ret_val = FALSE;
+ ret_val = false;
continue;
}
dynindx = 0;
{
long dynindx;
- dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
+ dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false);
if (dyn_i->want_fptr)
{
BFD_ASSERT (h == NULL || h->dynindx == -1);
- if (!undef_weak_ref)
- value = set_fptr_entry (output_bfd, info, dyn_i, value);
+ if (!undef_weak_ref)
+ value = set_fptr_entry (output_bfd, info, dyn_i, value);
dynindx = -1;
}
else
{
- /* Otherwise, we expect the dynamic linker to create
+ /* Otherwise, we expect the dynamic linker to create
the entry. */
- if (h)
+ if (h)
{
if (h->dynindx != -1)
dynindx = h->dynindx;
/* We should have created a PLT entry for any dynamic symbol. */
dyn_i = NULL;
if (h)
- dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, FALSE);
+ dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, false);
if (dyn_i && dyn_i->want_plt2)
{
if (r_type == R_IA64_PCREL21BI)
/* xgettext:c-format */
- msg = _("%B: @internal branch to dynamic symbol %s");
+ msg = _("%pB: @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");
+ msg = _("%pB: speculation fixup to dynamic symbol %s");
else
/* xgettext:c-format */
- msg = _("%B: @pcrel relocation against dynamic symbol %s");
+ msg = _("%pB: @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));
- ret_val = FALSE;
+ ret_val = false;
continue;
}
goto finish_pcrel;
got_r_type = R_IA64_DTPRELNNLSB;
break;
}
- dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
+ dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false);
value = set_got_entry (input_bfd, info, dyn_i, dynindx, r_addend,
value, got_r_type);
value -= gp_val;
don't try to continue. */
(*info->callbacks->undefined_symbol)
(info, "__gp", input_bfd, input_section, rel->r_offset, 1);
- return FALSE;
+ return false;
case bfd_reloc_notsupported:
{
(*info->callbacks->warning) (info, _("unsupported reloc"),
name, input_bfd,
input_section, rel->r_offset);
- ret_val = FALSE;
+ ret_val = false;
}
break;
case bfd_reloc_outofrange:
case bfd_reloc_overflow:
default:
-missing_tls_sec:
+ missing_tls_sec:
{
const char *name;
case R_IA64_LTOFF_DTPREL22:
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: missing TLS section for relocation %s against `%s'"
- " at 0x%lx in section `%A'."),
+ (_("%pB: missing TLS section for relocation %s against `%s'"
+ " at %#" PRIx64 " in section `%pA'."),
input_bfd, howto->name, name,
- rel->r_offset, input_section);
+ (uint64_t) rel->r_offset, input_section);
break;
case R_IA64_PCREL21B:
that the section is too big to relax. */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: Can't relax br (%s) to `%s' at 0x%lx"
- " in section `%A' with size 0x%lx (> 0x1000000)."),
- input_bfd, howto->name, name, rel->r_offset,
- input_section, input_section->size);
+ (_("%pB: Can't relax br (%s) to `%s' at %#" PRIx64
+ " in section `%pA' with size %#" PRIx64
+ " (> 0x1000000)."),
+ input_bfd, howto->name, name, (uint64_t) rel->r_offset,
+ input_section, (uint64_t) input_section->size);
break;
}
/* Fall through. */
break;
}
- ret_val = FALSE;
+ ret_val = false;
}
break;
}
return ret_val;
}
-static bfd_boolean
+static bool
elfNN_ia64_finish_dynamic_symbol (bfd *output_bfd,
struct bfd_link_info *info,
struct elf_link_hash_entry *h,
ia64_info = elfNN_ia64_hash_table (info);
if (ia64_info == NULL)
- return FALSE;
+ return false;
- dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, FALSE);
+ dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, false);
/* Fill in the PLT data, if required. */
if (dyn_i && dyn_i->want_plt)
plt_addr = (plt_sec->output_section->vma
+ plt_sec->output_offset
+ dyn_i->plt_offset);
- pltoff_addr = set_pltoff_entry (output_bfd, info, dyn_i, plt_addr, TRUE);
+ pltoff_addr = set_pltoff_entry (output_bfd, info, dyn_i, plt_addr, true);
/* Initialize the FULL PLT entry, if needed. */
if (dyn_i->want_plt2)
|| h == ia64_info->root.hplt)
sym->st_shndx = SHN_ABS;
- return TRUE;
+ return true;
}
-static bfd_boolean
+static bool
elfNN_ia64_finish_dynamic_sections (bfd *abfd,
struct bfd_link_info *info)
{
ia64_info = elfNN_ia64_hash_table (info);
if (ia64_info == NULL)
- return FALSE;
+ return false;
dynobj = ia64_info->root.dynobj;
}
}
- return TRUE;
+ return true;
}
\f
/* ELF file flag handling: */
/* Function to keep IA-64 specific file flags. */
-static bfd_boolean
+static bool
elfNN_ia64_set_private_flags (bfd *abfd, flagword flags)
{
BFD_ASSERT (!elf_flags_init (abfd)
|| elf_elfheader (abfd)->e_flags == flags);
elf_elfheader (abfd)->e_flags = flags;
- elf_flags_init (abfd) = TRUE;
- return TRUE;
+ elf_flags_init (abfd) = true;
+ return true;
}
/* Merge backend specific data from an object file to the output
object file when linking. */
-static bfd_boolean
+
+static bool
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;
+ bool ok = true;
+
+ /* FIXME: What should be checked when linking shared libraries? */
+ if ((ibfd->flags & DYNAMIC) != 0)
+ return true;
- /* Don't even pretend to support mixed-format linking. */
- if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
- || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
- return FALSE;
+ if (!is_ia64_elf (ibfd) || !is_ia64_elf (obfd))
+ return true;
in_flags = elf_elfheader (ibfd)->e_flags;
out_flags = elf_elfheader (obfd)->e_flags;
if (! elf_flags_init (obfd))
{
- elf_flags_init (obfd) = TRUE;
+ elf_flags_init (obfd) = true;
elf_elfheader (obfd)->e_flags = in_flags;
if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
bfd_get_mach (ibfd));
}
- return TRUE;
+ return true;
}
/* Check flag compatibility. */
if (in_flags == out_flags)
- return TRUE;
+ return true;
/* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set. */
if (!(in_flags & EF_IA_64_REDUCEDFP) && (out_flags & EF_IA_64_REDUCEDFP))
if ((in_flags & EF_IA_64_TRAPNIL) != (out_flags & EF_IA_64_TRAPNIL))
{
_bfd_error_handler
- (_("%B: linking trap-on-NULL-dereference with non-trapping files"),
+ (_("%pB: linking trap-on-NULL-dereference with non-trapping files"),
ibfd);
bfd_set_error (bfd_error_bad_value);
- ok = FALSE;
+ ok = false;
}
if ((in_flags & EF_IA_64_BE) != (out_flags & EF_IA_64_BE))
{
_bfd_error_handler
- (_("%B: linking big-endian files with little-endian files"),
+ (_("%pB: linking big-endian files with little-endian files"),
ibfd);
bfd_set_error (bfd_error_bad_value);
- ok = FALSE;
+ ok = false;
}
if ((in_flags & EF_IA_64_ABI64) != (out_flags & EF_IA_64_ABI64))
{
_bfd_error_handler
- (_("%B: linking 64-bit files with 32-bit files"),
+ (_("%pB: linking 64-bit files with 32-bit files"),
ibfd);
bfd_set_error (bfd_error_bad_value);
- ok = FALSE;
+ ok = false;
}
if ((in_flags & EF_IA_64_CONS_GP) != (out_flags & EF_IA_64_CONS_GP))
{
_bfd_error_handler
- (_("%B: linking constant-gp files with non-constant-gp files"),
+ (_("%pB: linking constant-gp files with non-constant-gp files"),
ibfd);
bfd_set_error (bfd_error_bad_value);
- ok = FALSE;
+ ok = false;
}
if ((in_flags & EF_IA_64_NOFUNCDESC_CONS_GP)
!= (out_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
{
_bfd_error_handler
- (_("%B: linking auto-pic files with non-auto-pic files"),
+ (_("%pB: linking auto-pic files with non-auto-pic files"),
ibfd);
bfd_set_error (bfd_error_bad_value);
- ok = FALSE;
+ ok = false;
}
return ok;
}
-static bfd_boolean
+static bool
elfNN_ia64_print_private_bfd_data (bfd *abfd, void * ptr)
{
FILE *file = (FILE *) ptr;
(flags & EF_IA_64_ABI64) ? "ABI64" : "ABI32");
_bfd_elf_print_private_bfd_data (abfd, ptr);
- return TRUE;
+ return true;
}
static enum elf_reloc_type_class
static const struct bfd_elf_special_section elfNN_ia64_special_sections[] =
{
- { STRING_COMMA_LEN (".sbss"), -1, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_IA_64_SHORT },
+ { STRING_COMMA_LEN (".sbss"), -1, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_IA_64_SHORT },
{ STRING_COMMA_LEN (".sdata"), -1, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_IA_64_SHORT },
- { NULL, 0, 0, 0, 0 }
+ { NULL, 0, 0, 0, 0 }
};
-static bfd_boolean
+static bool
elfNN_ia64_object_p (bfd *abfd)
{
asection *sec;
flagword flags;
const char *name;
char *unwi_name, *unw_name;
- bfd_size_type amt;
+ size_t amt;
if (abfd->flags & DYNAMIC)
- return TRUE;
+ return true;
/* Flags for fake group section. */
flags = (SEC_LINKER_CREATED | SEC_GROUP | SEC_LINK_ONCE
if (elf_sec_group (sec) == NULL
&& ((sec->flags & (SEC_LINK_ONCE | SEC_CODE | SEC_GROUP))
== (SEC_LINK_ONCE | SEC_CODE))
- && CONST_STRNEQ (sec->name, ".gnu.linkonce.t."))
+ && startswith (sec->name, ".gnu.linkonce.t."))
{
name = sec->name + 16;
amt = strlen (name) + sizeof (".gnu.linkonce.ia64unwi.");
unwi_name = bfd_alloc (abfd, amt);
if (!unwi_name)
- return FALSE;
+ return false;
strcpy (stpcpy (unwi_name, ".gnu.linkonce.ia64unwi."), name);
unwi = bfd_get_section_by_name (abfd, unwi_name);
amt = strlen (name) + sizeof (".gnu.linkonce.ia64unw.");
unw_name = bfd_alloc (abfd, amt);
if (!unw_name)
- return FALSE;
+ return false;
strcpy (stpcpy (unw_name, ".gnu.linkonce.ia64unw."), name);
unw = bfd_get_section_by_name (abfd, unw_name);
group = bfd_make_section_anyway_with_flags (abfd, name,
flags);
if (group == NULL)
- return FALSE;
+ return false;
/* Move the fake group section to the beginning. */
bfd_section_list_remove (abfd, group);
elf_section_data (group)->this_hdr.sh_type = SHT_GROUP;
}
}
- return TRUE;
+ return true;
}
-static bfd_boolean
+static bool
elfNN_ia64_hpux_vec (const bfd_target *vec)
{
extern const bfd_target ia64_elfNN_hpux_be_vec;
return (vec == &ia64_elfNN_hpux_be_vec);
}
-static void
-elfNN_hpux_post_process_headers (bfd *abfd,
- struct bfd_link_info *info ATTRIBUTE_UNUSED)
+static bool
+elfNN_hpux_init_file_header (bfd *abfd, struct bfd_link_info *info)
{
- Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
+ Elf_Internal_Ehdr *i_ehdrp;
+ if (!_bfd_elf_init_file_header (abfd, info))
+ return false;
+
+ i_ehdrp = elf_elfheader (abfd);
i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
i_ehdrp->e_ident[EI_ABIVERSION] = 1;
+ return true;
}
-static bfd_boolean
+static bool
elfNN_hpux_backend_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
asection *sec, int *retval)
{
if (bfd_is_com_section (sec))
{
*retval = SHN_IA_64_ANSI_COMMON;
- return TRUE;
+ return true;
}
- return FALSE;
+ return false;
}
static void
break;
}
}
+
+static void
+ignore_errors (const char *fmt ATTRIBUTE_UNUSED, ...)
+{
+}
\f
#define TARGET_LITTLE_SYM ia64_elfNN_le_vec
#define TARGET_LITTLE_NAME "elfNN-ia64-little"
elfNN_ia64_additional_program_headers
#define elf_backend_modify_segment_map \
elfNN_ia64_modify_segment_map
-#define elf_backend_modify_program_headers \
- elfNN_ia64_modify_program_headers
+#define elf_backend_modify_headers \
+ elfNN_ia64_modify_headers
#define elf_info_to_howto \
elfNN_ia64_info_to_howto
#define elf_backend_size_dynamic_sections \
elfNN_ia64_size_dynamic_sections
#define elf_backend_omit_section_dynsym \
- ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
+ _bfd_elf_omit_section_dynsym_all
#define elf_backend_relocate_section \
elfNN_ia64_relocate_section
#define elf_backend_finish_dynamic_symbol \
elfNN_ia64_print_private_bfd_data
#define elf_backend_plt_readonly 1
+#define elf_backend_can_gc_sections 1
#define elf_backend_want_plt_sym 0
#define elf_backend_plt_alignment 5
#define elf_backend_got_header_size 0
We don't want to flood users with so many error messages. We turn
off the warning for now. It will be turned on later when the Intel
compiler is fixed. */
-#define elf_backend_link_order_error_handler NULL
+#define elf_backend_link_order_error_handler ignore_errors
#include "elfNN-target.h"
#undef TARGET_LITTLE_SYM
#undef TARGET_LITTLE_NAME
#undef TARGET_BIG_SYM
-#define TARGET_BIG_SYM ia64_elfNN_hpux_be_vec
-#undef TARGET_BIG_NAME
-#define TARGET_BIG_NAME "elfNN-ia64-hpux-big"
+#define TARGET_BIG_SYM ia64_elfNN_hpux_be_vec
+#undef TARGET_BIG_NAME
+#define TARGET_BIG_NAME "elfNN-ia64-hpux-big"
/* These are HP-UX specific functions. */
-#undef elf_backend_post_process_headers
-#define elf_backend_post_process_headers elfNN_hpux_post_process_headers
+#undef elf_backend_init_file_header
+#define elf_backend_init_file_header elfNN_hpux_init_file_header
#undef elf_backend_section_from_bfd_section
#define elf_backend_section_from_bfd_section elfNN_hpux_backend_section_from_bfd_section
projects / deliverable / binutils-gdb.git / blobdiff