/* FRV-specific support for 32-bit ELF.
- Copyright (C) 2002-2014 Free Software Foundation, Inc.
+ Copyright (C) 2002-2015 Free Software Foundation, Inc.
This file is part of BFD, the Binary File Descriptor library.
/* 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 */
/* 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)))
{
break;
default:
+ if (r_type >= (unsigned int) R_FRV_max)
+ {
+ _bfd_error_handler (_("%B: invalid FRV reloc number: %d"), abfd, r_type);
+ r_type = 0;
+ }
cache_ptr->howto = & elf32_frv_howto_table [r_type];
break;
}
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;
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
{
#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) \
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;
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;
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)
/* 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
(_("%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;
}
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
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
{
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
bfd *dynobj;
struct frvfdpic_relocs_info *picrel;
- if (info->relocatable)
+ if (bfd_link_relocatable (info))
return TRUE;
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;