/* FRV-specific support for 32-bit ELF.
- Copyright (C) 2002-2014 Free Software Foundation, Inc.
+ Copyright (C) 2002-2020 Free Software Foundation, Inc.
This file is part of BFD, the Binary File Descriptor library.
#include "elf/frv.h"
#include "dwarf2.h"
#include "hashtab.h"
+#include "libiberty.h"
/* Forward declarations. */
/* This reloc does nothing. */
HOWTO (R_FRV_NONE, /* type */
0, /* rightshift */
- 2, /* size (0 = byte, 1 = short, 2 = long) */
- 32, /* bitsize */
+ 3, /* size (0 = byte, 1 = short, 2 = long) */
+ 0, /* bitsize */
FALSE, /* pc_relative */
0, /* bitpos */
- complain_overflow_bitfield, /* complain_on_overflow */
+ complain_overflow_dont, /* complain_on_overflow */
bfd_elf_generic_reloc, /* special_function */
"R_FRV_NONE", /* name */
FALSE, /* partial_inplace */
{
struct elf_link_hash_table elf;
- /* A pointer to the .got section. */
- asection *sgot;
- /* A pointer to the .rel.got section. */
- asection *sgotrel;
/* A pointer to the .rofixup section. */
asection *sgotfixup;
- /* A pointer to the .plt section. */
- asection *splt;
- /* A pointer to the .rel.plt section. */
- asection *spltrel;
/* GOT base offset. */
bfd_vma got0;
/* Location of the first non-lazy PLT entry, i.e., the number of
== FRV_ELF_DATA ? ((struct frvfdpic_elf_link_hash_table *) ((p)->hash)) : NULL)
#define frvfdpic_got_section(info) \
- (frvfdpic_hash_table (info)->sgot)
+ (frvfdpic_hash_table (info)->elf.sgot)
#define frvfdpic_gotrel_section(info) \
- (frvfdpic_hash_table (info)->sgotrel)
+ (frvfdpic_hash_table (info)->elf.srelgot)
#define frvfdpic_gotfixup_section(info) \
(frvfdpic_hash_table (info)->sgotfixup)
#define frvfdpic_plt_section(info) \
- (frvfdpic_hash_table (info)->splt)
+ (frvfdpic_hash_table (info)->elf.splt)
#define frvfdpic_pltrel_section(info) \
- (frvfdpic_hash_table (info)->spltrel)
+ (frvfdpic_hash_table (info)->elf.srelplt)
#define frvfdpic_relocs_info(info) \
(frvfdpic_hash_table (info)->relocs_info)
#define frvfdpic_got_initial_offset(info) \
frvfdpic_elf_link_hash_table_create (bfd *abfd)
{
struct frvfdpic_elf_link_hash_table *ret;
- bfd_size_type amt = sizeof (struct frvfdpic_elf_link_hash_table);
+ size_t amt = sizeof (struct frvfdpic_elf_link_hash_table);
ret = bfd_zmalloc (amt);
if (ret == NULL)
for symbol+addend. Should be implied by something like:
(plt || fdgotoff12 || fdgotofflos || fdgotofflohi
|| ((fd || fdgot12 || fdgotlos || fdgothilo)
- && (symndx != -1 || FRVFDPIC_FUNCDESC_LOCAL (info, d.h)))) */
+ && (symndx != -1 || FRVFDPIC_FUNCDESC_LOCAL (info, d.h)))) */
unsigned privfd:1;
/* Whether a lazy PLT entry is needed for this symbol+addend.
Should be implied by something like:
/* If we're linking an executable at a fixed address, we can
omit the dynamic relocation as long as the symbol is local to
this module. */
- if (info->executable && !info->pie
+ if (bfd_link_pde (info)
&& (entry->symndx != -1
|| FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
{
if (entry->symndx == -1
&& ! FRVFDPIC_FUNCDESC_LOCAL (info, entry->d.h)
&& FRVFDPIC_SYM_LOCAL (info, entry->d.h)
- && !(info->executable && !info->pie))
+ && !bfd_link_pde (info))
{
reloc = R_FRV_FUNCDESC;
idx = elf_section_data (entry->d.h->root.u.def.section
dynamic symbol entry for the got section, so idx will be
zero, which means we can and should compute the address
of the private descriptor ourselves. */
- if (info->executable && !info->pie
+ if (bfd_link_pde (info)
&& (entry->symndx != -1
|| FRVFDPIC_FUNCDESC_LOCAL (info, entry->d.h)))
{
/* If we're linking an executable at a fixed address, we can
omit the dynamic relocation as long as the symbol is local to
this module. */
- if (info->executable && !info->pie
+ if (bfd_link_pde (info)
&& (entry->symndx != -1 || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
{
if (sec)
/* If we've omitted the dynamic relocation, just emit the fixed
addresses of the symbol and of the local GOT base offset. */
- if (info->executable && !info->pie && sec && sec->output_section)
+ if (bfd_link_pde (info)
+ && sec
+ && sec->output_section)
{
lowword = ad;
highword = frvfdpic_got_section (info)->output_section->vma
/* *ABS*+addend is special for TLS relocations, use only the
addend. */
- if (info->executable
+ if (bfd_link_executable (info)
&& idx == 0
&& (bfd_is_abs_section (sec)
|| bfd_is_und_section (sec)))
;
/* If we're linking an executable, we can entirely omit the
dynamic relocation if the symbol is local to this module. */
- else if (info->executable
+ else if (bfd_link_executable (info)
&& (entry->symndx != -1
|| FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
{
/* If we didn't set up a TLS offset entry, but we're linking an
executable and the symbol binds locally, we can use the
module offset in the TLS descriptor in relaxations. */
- if (info->executable && ! entry->tlsoff_entry)
+ if (bfd_link_executable (info) && ! entry->tlsoff_entry)
entry->tlsoff_entry = entry->tlsdesc_entry + 4;
- if (info->executable && !info->pie
+ if (bfd_link_pde (info)
&& ((idx == 0
&& (bfd_is_abs_section (sec)
|| bfd_is_und_section (sec)))
bfd_byte *plt_code = frvfdpic_plt_section (info)->contents
+ entry->tlsplt_entry;
- if (info->executable
+ if (bfd_link_executable (info)
&& (entry->symndx != -1
|| FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
{
h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
gp = (h->u.def.value
- + h->u.def.section->output_section->vma
- + h->u.def.section->output_offset);
+ + h->u.def.section->output_section->vma
+ + h->u.def.section->output_offset);
value -= input_section->output_section->vma;
value -= (gp - input_section->output_section->vma);
h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
gp = (h->u.def.value
- + h->u.def.section->output_section->vma
- + h->u.def.section->output_offset);
+ + h->u.def.section->output_section->vma
+ + h->u.def.section->output_offset);
value -= input_section->output_section->vma;
value -= (gp - input_section->output_section->vma);
/* Set the howto pointer for an FRV ELF reloc. */
-static void
+static bfd_boolean
frv_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
arelent *cache_ptr,
Elf_Internal_Rela *dst)
break;
default:
- if (r_type >= (unsigned int) R_FRV_max)
+ if (r_type >= ARRAY_SIZE (elf32_frv_howto_table))
{
- _bfd_error_handler (_("%A: invalid FRV reloc number: %d"), abfd, r_type);
- r_type = 0;
+ /* xgettext:c-format */
+ _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
+ abfd, r_type);
+ bfd_set_error (bfd_error_bad_value);
+ return FALSE;
}
cache_ptr->howto = & elf32_frv_howto_table [r_type];
break;
}
+ return TRUE;
}
/* Set the howto pointer for an FRV ELF REL reloc. */
-static void
+
+static bfd_boolean
frvfdpic_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
arelent *cache_ptr, Elf_Internal_Rela *dst)
{
default:
cache_ptr->howto = NULL;
- break;
+ return FALSE;
}
+ return TRUE;
}
\f
/* Perform a single relocation. By default we use the standard BFD
Elf_Internal_Rela *relend;
unsigned isec_segment, got_segment, plt_segment, gprel_segment, tls_segment,
check_segment[2];
- int silence_segment_error = !(info->shared || info->pie);
+ int silence_segment_error = !bfd_link_pic (info);
unsigned long insn;
symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
name = bfd_elf_string_from_elf_section
(input_bfd, symtab_hdr->sh_link, sym->st_name);
if (name == NULL || name[0] == 0)
- name = bfd_section_name (input_bfd, sec);
+ name = bfd_section_name (sec);
}
else
{
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 (r_type != R_FRV_TLSMOFF
case R_FRV_32:
if (! IS_FDPIC (output_bfd))
goto non_fdpic;
+ /* Fall through. */
case R_FRV_GOT12:
case R_FRV_GOTHI:
rel->r_addend))
{
info->callbacks->einfo
+ /* xgettext:c-format */
(_("%H: relocation to `%s+%v'"
" may have caused the error above\n"),
input_bfd, input_section, rel->r_offset, name, rel->r_addend);
{
#define LOCAL_EXEC_P(info, picrel) \
- ((info)->executable \
+ (bfd_link_executable (info) \
&& (picrel->symndx != -1 || FRVFDPIC_SYM_LOCAL ((info), (picrel)->d.h)))
#define INITIAL_EXEC_P(info, picrel) \
- (((info)->executable || (info)->flags & DF_STATIC_TLS) \
+ ((bfd_link_executable (info)|| (info)->flags & DF_STATIC_TLS) \
&& (picrel)->tlsoff_entry)
#define IN_RANGE_FOR_OFST12_P(value) \
bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
/* #tlsoff(symbol+offset) is just a relaxation
- annotation, so there's nothing left to
- relocate. */
+ annotation, so there's nothing left to
+ relocate. */
continue;
}
section+offset. */
if (h && ! FRVFDPIC_FUNCDESC_LOCAL (info, h)
&& FRVFDPIC_SYM_LOCAL (info, h)
- && !(info->executable && !info->pie))
+ && !bfd_link_pde (info))
{
dynindx = elf_section_data (h->root.u.def.section
->output_section)->dynindx;
if (addend)
{
info->callbacks->einfo
- (_("%H: R_FRV_FUNCDESC references dynamic symbol"
+ (_("%H: %s references dynamic symbol"
" with nonzero addend\n"),
- input_bfd, input_section, rel->r_offset);
+ input_bfd, input_section, rel->r_offset,
+ "R_FRV_FUNCDESC");
return FALSE;
}
dynindx = h->dynindx;
dynamic symbol entry for the got section, so idx will
be zero, which means we can and should compute the
address of the private descriptor ourselves. */
- if (info->executable && !info->pie
+ if (bfd_link_pde (info)
&& (!h || FRVFDPIC_FUNCDESC_LOCAL (info, h)))
{
addend += frvfdpic_got_section (info)->output_section->vma;
- if ((bfd_get_section_flags (output_bfd,
- input_section->output_section)
+ if ((bfd_section_flags (input_section->output_section)
& (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
{
bfd_vma offset;
picrel);
}
}
- else if ((bfd_get_section_flags (output_bfd,
- input_section->output_section)
+ else if ((bfd_section_flags (input_section->output_section)
& (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
{
bfd_vma offset;
if (addend && r_type == R_FRV_FUNCDESC_VALUE)
{
info->callbacks->einfo
- (_("%H: R_FRV_FUNCDESC_VALUE"
- " references dynamic symbol with nonzero addend\n"),
- input_bfd, input_section, rel->r_offset);
+ (_("%H: %s references dynamic symbol"
+ " with nonzero addend\n"),
+ input_bfd, input_section, rel->r_offset,
+ "R_FRV_FUNCDESC_VALUE");
return FALSE;
}
dynindx = h->dynindx;
can omit the dynamic relocation as long as the symbol
is defined in the current link unit (which is implied
by its output section not being NULL). */
- if (info->executable && !info->pie
+ if (bfd_link_pde (info)
&& (!h || FRVFDPIC_SYM_LOCAL (info, h)))
{
if (osec)
addend += osec->output_section->vma;
if (IS_FDPIC (input_bfd)
- && (bfd_get_section_flags (output_bfd,
- input_section->output_section)
+ && (bfd_section_flags (input_section->output_section)
& (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
{
if (_frvfdpic_osec_readonly_p (output_bfd,
}
else
{
- if ((bfd_get_section_flags (output_bfd,
- input_section->output_section)
+ if ((bfd_section_flags (input_section->output_section)
& (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
{
bfd_vma offset;
/* If we've omitted the dynamic relocation, just emit
the fixed addresses of the symbol and of the local
GOT base offset. */
- if (info->executable && !info->pie
+ if (bfd_link_pde (info)
&& (!h || FRVFDPIC_SYM_LOCAL (info, h)))
bfd_put_32 (output_bfd,
frvfdpic_got_section (info)->output_section->vma
&& picrel->d.h->root.type == bfd_link_hash_undefined))
{
info->callbacks->einfo
+ /* xgettext:c-format */
(_("%H: reloc against `%s' references a different segment\n"),
input_bfd, input_section, rel->r_offset, name);
}
- if (!silence_segment_error && (info->shared || info->pie))
+ if (!silence_segment_error && bfd_link_pic (info))
return FALSE;
elf_elfheader (output_bfd)->e_flags |= EF_FRV_PIC;
}
switch (r)
{
case bfd_reloc_overflow:
- r = info->callbacks->reloc_overflow
+ (*info->callbacks->reloc_overflow)
(info, (h ? &h->root : NULL), name, howto->name,
(bfd_vma) 0, input_bfd, input_section, rel->r_offset);
break;
case bfd_reloc_undefined:
- r = info->callbacks->undefined_symbol
+ (*info->callbacks->undefined_symbol)
(info, name, input_bfd, input_section, rel->r_offset, TRUE);
break;
if (msg)
{
info->callbacks->einfo
+ /* xgettext:c-format */
(_("%H: reloc against `%s': %s\n"),
input_bfd, input_section, rel->r_offset, name, msg);
return FALSE;
}
-
- if (! r)
- return FALSE;
}
}
bfd_vma *valp)
{
if (sym->st_shndx == SHN_COMMON
- && !info->relocatable
+ && !bfd_link_relocatable (info)
&& (int)sym->st_size <= (int)bfd_get_gp_size (abfd))
{
/* Common symbols less than or equal to -G nn bytes are
int offset;
/* This function may be called more than once. */
- s = bfd_get_linker_section (abfd, ".got");
+ s = elf_hash_table (info)->sgot;
if (s != NULL)
return TRUE;
pltflags = flags;
s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
+ elf_hash_table (info)->sgot = s;
if (s == NULL
- || !bfd_set_section_alignment (abfd, s, ptralign))
+ || !bfd_set_section_alignment (s, ptralign))
return FALSE;
- if (bed->want_got_plt)
- {
- s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags);
- if (s == NULL
- || !bfd_set_section_alignment (abfd, s, ptralign))
- return FALSE;
- }
-
if (bed->want_got_sym)
{
/* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
data for the got. */
if (IS_FDPIC (abfd))
{
- frvfdpic_got_section (info) = s;
frvfdpic_relocs_info (info) = htab_try_create (1,
frvfdpic_relocs_info_hash,
frvfdpic_relocs_info_eq,
s = bfd_make_section_anyway_with_flags (abfd, ".rel.got",
(flags | SEC_READONLY));
+ elf_hash_table (info)->srelgot = s;
if (s == NULL
- || ! bfd_set_section_alignment (abfd, s, 2))
+ || !bfd_set_section_alignment (s, 2))
return FALSE;
- frvfdpic_gotrel_section (info) = s;
-
/* Machine-specific. */
s = bfd_make_section_anyway_with_flags (abfd, ".rofixup",
(flags | SEC_READONLY));
if (s == NULL
- || ! bfd_set_section_alignment (abfd, s, 2))
+ || !bfd_set_section_alignment (s, 2))
return FALSE;
frvfdpic_gotfixup_section (info) = s;
s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
if (s == NULL
- || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
+ || !bfd_set_section_alignment (s, bed->plt_alignment))
return FALSE;
/* FRV-specific: remember it. */
frvfdpic_plt_section (info) = s;
s = bfd_make_section_anyway_with_flags (abfd, ".rel.plt",
flags | SEC_READONLY);
if (s == NULL
- || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
+ || !bfd_set_section_alignment (s, bed->s->log_file_align))
return FALSE;
/* FRV-specific: remember it. */
frvfdpic_pltrel_section (info) = s;
be needed, we can discard it later. We will never need this
section when generating a shared object, since they do not use
copy relocs. */
- if (! info->shared)
+ if (! bfd_link_pic (info))
{
s = bfd_make_section_anyway_with_flags (abfd,
(bed->default_use_rela_p
? ".rela.bss" : ".rel.bss"),
flags | SEC_READONLY);
if (s == NULL
- || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
+ || !bfd_set_section_alignment (s, bed->s->log_file_align))
return FALSE;
}
}
{
bfd_vma relocs = 0, fixups = 0, tlsrets = 0;
- if (!dinfo->info->executable || dinfo->info->pie)
+ if (!bfd_link_pde (dinfo->info))
{
relocs = entry->relocs32 + entry->relocsfd + entry->relocsfdv
+ entry->relocstlsd;
emit dynamic relocations even for local symbols, because we
don't know the module id the library is going to get at
run-time, nor its TLS base offset. */
- if (!dinfo->info->executable
+ if (!bfd_link_executable (dinfo->info)
|| (entry->symndx == -1
&& ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)))
relocs += entry->relocstlsoff;
{
bfd_boolean changed = ! relaxing;
- BFD_ASSERT (dinfo->info->executable
+ BFD_ASSERT (bfd_link_executable (dinfo->info)
|| (dinfo->info->flags & DF_STATIC_TLS));
if (entry->tlsdesc12 || entry->tlsdesclos || entry->tlsdeschilo)
to GOTTLSOFF, we must keep the GOT entry in range. We know
it has to fit because we'll be trading the 4 words of hte TLS
descriptor for a single word in the same range. */
- if (! dinfo->info->executable
+ if (! bfd_link_executable (dinfo->info)
|| (entry->symndx == -1
&& ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)))
{
do better than this. */
if ((entry->tlsplt
|| entry->tlsoff12 || entry->tlsofflos || entry->tlsoffhilo)
- && dinfo->info->executable && relaxing
+ && bfd_link_executable (dinfo->info) && relaxing
&& ((entry->symndx == -1
&& FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
/* The above may hold for an undefweak TLS symbol, so make
+ 32768) < (bfd_vma)65536))
|| (entry->symndx != -1
&& (elf_hash_table (dinfo->info)->tls_sec->size
- + abs (entry->addend) < 32768 + FRVFDPIC_TLS_BIAS))))
+ + entry->addend < 32768 + FRVFDPIC_TLS_BIAS))))
{
if (! changed)
{
_frvfdpic_count_nontls_entries (entry, dinfo);
- if (dinfo->info->executable || (dinfo->info->flags & DF_STATIC_TLS))
+ if (bfd_link_executable (dinfo->info)
+ || (dinfo->info->flags & DF_STATIC_TLS))
_frvfdpic_relax_tls_entries (entry, dinfo, FALSE);
else
{
entry->tlsplt_entry
= frvfdpic_plt_section (dinfo->g.info)->size;
- if (dinfo->g.info->executable
+ if (bfd_link_executable (dinfo->g.info)
&& (entry->symndx != -1
|| FRVFDPIC_SYM_LOCAL (dinfo->g.info, entry->d.h)))
{
if (elf_hash_table (info)->dynamic_sections_created)
{
/* Set the contents of the .interp section to the interpreter. */
- if (info->executable)
+ if (bfd_link_executable (info) && !info->nointerp)
{
s = bfd_get_linker_section (dynobj, ".interp");
BFD_ASSERT (s != NULL);
elf32_frvfdpic_always_size_sections (bfd *output_bfd,
struct bfd_link_info *info)
{
- if (!info->relocatable
+ if (!bfd_link_relocatable (info)
&& !bfd_elf_stack_segment_size (output_bfd, info,
"__stacksize", DEFAULT_STACK_SIZE))
return FALSE;
{
struct _frvfdpic_dynamic_got_plt_info gpinfo;
- if (info->relocatable)
+ if (bfd_link_relocatable (info))
(*info->callbacks->einfo)
(_("%P%F: --relax and -r may not be used together\n"));
/* We can only relax when linking the main executable or a library
that can't be dlopened. */
- if (! info->executable && ! (info->flags & DF_STATIC_TLS))
+ if (! bfd_link_executable (info) && ! (info->flags & DF_STATIC_TLS))
return TRUE;
/* If there isn't a TLS section for this binary, we can't do
/* Make sure we know what is going on here. */
BFD_ASSERT (dynobj != NULL
- && (h->u.weakdef != NULL
+ && (h->is_weakalias
|| (h->def_dynamic
&& h->ref_regular
&& !h->def_regular)));
/* 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;
+ 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;
}
return TRUE;
bfd *dynobj;
struct frvfdpic_relocs_info *picrel;
- if (info->relocatable)
+ if (bfd_link_relocatable (info))
return TRUE;
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
r_symndx = ELF32_R_SYM (rel->r_info);
if (r_symndx < symtab_hdr->sh_info)
- h = NULL;
+ h = NULL;
else
{
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
while (h->root.type == bfd_link_hash_indirect
|| h->root.type == bfd_link_hash_warning)
h = (struct elf_link_hash_entry *) h->root.u.i.link;
-
- /* PR15323, ref flags aren't set for references in the same
- object. */
- h->root.non_ir_ref = 1;
}
switch (ELF32_R_TYPE (rel->r_info))
}
switch (ELF32_R_TYPE (rel->r_info))
- {
+ {
case R_FRV_LABEL24:
if (IS_FDPIC (abfd))
picrel->call = 1;
case R_FRV_FUNCDESC_VALUE:
picrel->relocsfdv++;
- if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
+ if (bfd_section_flags (sec) & SEC_ALLOC)
picrel->relocs32--;
/* Fall through. */
break;
picrel->sym = 1;
- if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
+ if (bfd_section_flags (sec) & SEC_ALLOC)
picrel->relocs32++;
break;
info->flags |= DF_STATIC_TLS;
goto bad_reloc;
- /* This relocation describes the C++ object vtable hierarchy.
- Reconstruct it for later use during GC. */
- case R_FRV_GNU_VTINHERIT:
- if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
- return FALSE;
- break;
-
- /* This relocation describes which C++ vtable entries are actually
- used. Record for later use during GC. */
- case R_FRV_GNU_VTENTRY:
- BFD_ASSERT (h != NULL);
- if (h != NULL
- && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
- return FALSE;
- break;
+ /* This relocation describes the C++ object vtable hierarchy.
+ Reconstruct it for later use during GC. */
+ case R_FRV_GNU_VTINHERIT:
+ if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
+ return FALSE;
+ break;
+
+ /* This relocation describes which C++ vtable entries are actually
+ used. Record for later use during GC. */
+ case R_FRV_GNU_VTENTRY:
+ if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
+ return FALSE;
+ break;
case R_FRV_LABEL16:
case R_FRV_LO16:
default:
bad_reloc:
- info->callbacks->einfo
- (_("%B: unsupported relocation type %i\n"),
- abfd, ELF32_R_TYPE (rel->r_info));
+ /* xgettext:c-format */
+ _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
+ abfd, (unsigned int) ELF32_R_TYPE (rel->r_info));
return FALSE;
- }
+ }
}
return TRUE;
object file when linking. */
static bfd_boolean
-frv_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
+frv_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
{
+ bfd *obfd = info->output_bfd;
flagword old_flags, old_partial;
flagword new_flags, new_partial;
bfd_boolean error = FALSE;
new_flags &= ~EF_FRV_PIC;
#ifdef DEBUG
- (*_bfd_error_handler) ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
- old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no",
- bfd_get_filename (ibfd));
+ _bfd_error_handler
+ ("old_flags = 0x%.8x, new_flags = 0x%.8x, init = %s, filename = %s",
+ old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no",
+ bfd_get_filename (ibfd));
#endif
if (!elf_flags_init (obfd)) /* First call, no flags set. */
else /* Possibly incompatible flags. */
{
/* Warn if different # of gprs are used. Note, 0 means nothing is
- said about the size of gprs. */
+ said about the size of gprs. */
new_partial = (new_flags & EF_FRV_GPR_MASK);
old_partial = (old_flags & EF_FRV_GPR_MASK);
if (new_partial == old_partial)
}
/* Warn if different # of fprs are used. Note, 0 means nothing is
- said about the size of fprs. */
+ said about the size of fprs. */
new_partial = (new_flags & EF_FRV_FPR_MASK);
old_partial = (old_flags & EF_FRV_FPR_MASK);
if (new_partial == old_partial)
}
/* Warn if different dword support was used. Note, 0 means nothing is
- said about the dword support. */
+ said about the dword support. */
new_partial = (new_flags & EF_FRV_DWORD_MASK);
old_partial = (old_flags & EF_FRV_DWORD_MASK);
if (new_partial == old_partial)
| (old_flags & new_flags & EF_FRV_NOPACK));
/* We don't have to do anything if the pic flags are the same, or the new
- module(s) were compiled with -mlibrary-pic. */
+ module(s) were compiled with -mlibrary-pic. */
new_partial = (new_flags & EF_FRV_PIC_FLAGS);
old_partial = (old_flags & EF_FRV_PIC_FLAGS);
if ((new_partial == old_partial) || ((new_partial & EF_FRV_LIBPIC) != 0))
;
/* If the old module(s) were compiled with -mlibrary-pic, copy in the pic
- flags if any from the new module. */
+ flags if any from the new module. */
else if ((old_partial & EF_FRV_LIBPIC) != 0)
old_flags = (old_flags & ~ EF_FRV_PIC_FLAGS) | new_partial;
old_flags |= new_partial;
/* One module was compiled for pic and the other was not, see if we have
- had any relocations that are not pic-safe. */
+ had any relocations that are not pic-safe. */
else
{
if ((old_flags & EF_FRV_NON_PIC_RELOCS) == 0)
old_flags &= ~ EF_FRV_PIC_FLAGS;
#ifndef FRV_NO_PIC_ERROR
error = TRUE;
- (*_bfd_error_handler)
- (_("%s: compiled with %s and linked with modules that use non-pic relocations"),
- bfd_get_filename (ibfd),
- (new_flags & EF_FRV_BIGPIC) ? "-fPIC" : "-fpic");
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: compiled with %s and linked with modules"
+ " that use non-pic relocations"),
+ ibfd, (new_flags & EF_FRV_BIGPIC) ? "-fPIC" : "-fpic");
#endif
}
}
if (new_opt[0])
{
error = TRUE;
- (*_bfd_error_handler)
- (_("%s: compiled with %s and linked with modules compiled with %s"),
- bfd_get_filename (ibfd), new_opt, old_opt);
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: compiled with %s and linked with modules compiled with %s"),
+ ibfd, new_opt, old_opt);
}
/* Warn about any other mismatches */
{
old_flags |= new_partial;
error = TRUE;
- (*_bfd_error_handler)
- (_("%s: uses different unknown e_flags (0x%lx) fields than previous modules (0x%lx)"),
- bfd_get_filename (ibfd), (long)new_partial, (long)old_partial);
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: uses different unknown e_flags (%#x) fields"
+ " than previous modules (%#x)"),
+ ibfd, new_partial, old_partial);
}
}
{
error = TRUE;
if (IS_FDPIC (obfd))
- (*_bfd_error_handler)
- (_("%s: cannot link non-fdpic object file into fdpic executable"),
- bfd_get_filename (ibfd));
+ _bfd_error_handler
+ (_("%pB: cannot link non-fdpic object file into fdpic executable"),
+ ibfd);
else
- (*_bfd_error_handler)
- (_("%s: cannot link fdpic object file into non-fdpic executable"),
- bfd_get_filename (ibfd));
+ _bfd_error_handler
+ (_("%pB: cannot link fdpic object file into non-fdpic executable"),
+ ibfd);
}
if (error)
return FALSE;
/* The Linux/FRV elf_prstatus struct is 268 bytes long. The other
- hardcoded offsets and sizes listed below (and contained within
+ hardcoded offsets and sizes listed below (and contained within
this lexical block) refer to fields in the target's elf_prstatus
struct. */
case 268:
return TRUE;
}
#define ELF_ARCH bfd_arch_frv
-#define ELF_TARGET_ID FRV_ELF_DATA
#define ELF_MACHINE_CODE EM_CYGNUS_FRV
#define ELF_MAXPAGESIZE 0x1000
-#define TARGET_BIG_SYM frv_elf32_vec
+#define TARGET_BIG_SYM frv_elf32_vec
#define TARGET_BIG_NAME "elf32-frv"
#define elf_info_to_howto frv_info_to_howto_rela
#define elf_backend_relocate_section elf32_frv_relocate_section
#define elf_backend_gc_mark_hook elf32_frv_gc_mark_hook
-#define elf_backend_check_relocs elf32_frv_check_relocs
+#define elf_backend_check_relocs elf32_frv_check_relocs
#define elf_backend_object_p elf32_frv_object_p
-#define elf_backend_add_symbol_hook elf32_frv_add_symbol_hook
+#define elf_backend_add_symbol_hook elf32_frv_add_symbol_hook
#define elf_backend_stack_align 8
#define elf_backend_can_gc_sections 1
#define elf_backend_grok_prstatus elf32_frv_grok_prstatus
#define elf_backend_grok_psinfo elf32_frv_grok_psinfo
+#define elf_backend_linux_prpsinfo32_ugid16 TRUE
+
#include "elf32-target.h"
+#undef ELF_TARGET_ID
+#define ELF_TARGET_ID FRV_ELF_DATA
#undef ELF_MAXPAGESIZE
#define ELF_MAXPAGESIZE 0x4000
#undef TARGET_BIG_SYM
-#define TARGET_BIG_SYM frv_elf32_fdpic_vec
+#define TARGET_BIG_SYM frv_elf32_fdpic_vec
#undef TARGET_BIG_NAME
#define TARGET_BIG_NAME "elf32-frvfdpic"
#undef elf32_bed
frvfdpic_elf_encode_eh_address
#undef elf_backend_may_use_rel_p
-#define elf_backend_may_use_rel_p 1
+#define elf_backend_may_use_rel_p 1
#undef elf_backend_may_use_rela_p
-#define elf_backend_may_use_rela_p 1
+#define elf_backend_may_use_rela_p 1
/* We use REL for dynamic relocations only. */
#undef elf_backend_default_use_rela_p
-#define elf_backend_default_use_rela_p 1
+#define elf_backend_default_use_rela_p 1
#undef elf_backend_omit_section_dynsym
#define elf_backend_omit_section_dynsym _frvfdpic_link_omit_section_dynsym