/* CRIS-specific support for 32-bit ELF.
- Copyright (C) 2000-2014 Free Software Foundation, Inc.
+ Copyright (C) 2000-2021 Free Software Foundation, Inc.
Contributed by Axis Communications AB.
Written by Hans-Peter Nilsson, based on elf32-fr30.c
PIC and shlib bits based primarily on elf32-m68k.c and elf32-i386.c.
bfd_reloc_status_type
cris_elf_pcrel_reloc (bfd *, arelent *, asymbol *, void *,
asection *, bfd *, char **);
-static bfd_boolean
+static bool
cris_elf_set_mach_from_flags (bfd *, unsigned long);
/* Forward declarations. */
/* This reloc does nothing. */
HOWTO (R_CRIS_NONE, /* type */
0, /* rightshift */
- 2, /* size (0 = byte, 1 = short, 2 = long) */
- 32, /* bitsize */
- FALSE, /* pc_relative */
+ 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_CRIS_NONE", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0, /* src_mask */
0, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
/* An 8 bit absolute relocation. */
HOWTO (R_CRIS_8, /* type */
0, /* rightshift */
0, /* size (0 = byte, 1 = short, 2 = long) */
8, /* bitsize */
- FALSE, /* pc_relative */
+ false, /* pc_relative */
0, /* bitpos */
complain_overflow_bitfield, /* complain_on_overflow */
bfd_elf_generic_reloc, /* special_function */
"R_CRIS_8", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0x0000, /* src_mask */
0x00ff, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
/* A 16 bit absolute relocation. */
HOWTO (R_CRIS_16, /* type */
0, /* rightshift */
1, /* size (0 = byte, 1 = short, 2 = long) */
16, /* bitsize */
- FALSE, /* pc_relative */
+ false, /* pc_relative */
0, /* bitpos */
complain_overflow_bitfield, /* complain_on_overflow */
bfd_elf_generic_reloc, /* special_function */
"R_CRIS_16", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0x00000000, /* src_mask */
0x0000ffff, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
/* A 32 bit absolute relocation. */
HOWTO (R_CRIS_32, /* type */
0, /* rightshift */
2, /* size (0 = byte, 1 = short, 2 = long) */
32, /* bitsize */
- FALSE, /* pc_relative */
+ false, /* pc_relative */
0, /* bitpos */
/* We don't want overflow complaints for 64-bit vma builds
for e.g. sym+0x40000000 (or actually sym-0xc0000000 in
complain_overflow_dont, /* complain_on_overflow */
bfd_elf_generic_reloc, /* special_function */
"R_CRIS_32", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0x00000000, /* src_mask */
0xffffffff, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
/* An 8 bit PC-relative relocation. */
HOWTO (R_CRIS_8_PCREL, /* type */
0, /* rightshift */
0, /* size (0 = byte, 1 = short, 2 = long) */
8, /* bitsize */
- TRUE, /* pc_relative */
+ true, /* pc_relative */
0, /* bitpos */
complain_overflow_bitfield, /* complain_on_overflow */
cris_elf_pcrel_reloc, /* special_function */
"R_CRIS_8_PCREL", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0x0000, /* src_mask */
0x00ff, /* dst_mask */
- TRUE), /* pcrel_offset */
+ true), /* pcrel_offset */
/* A 16 bit PC-relative relocation. */
HOWTO (R_CRIS_16_PCREL, /* type */
0, /* rightshift */
1, /* size (0 = byte, 1 = short, 2 = long) */
16, /* bitsize */
- TRUE, /* pc_relative */
+ true, /* pc_relative */
0, /* bitpos */
complain_overflow_bitfield, /* complain_on_overflow */
cris_elf_pcrel_reloc, /* special_function */
"R_CRIS_16_PCREL", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0x00000000, /* src_mask */
0x0000ffff, /* dst_mask */
- TRUE), /* pcrel_offset */
+ true), /* pcrel_offset */
/* A 32 bit PC-relative relocation. */
HOWTO (R_CRIS_32_PCREL, /* type */
0, /* rightshift */
2, /* size (0 = byte, 1 = short, 2 = long) */
32, /* bitsize */
- TRUE, /* pc_relative */
+ true, /* pc_relative */
0, /* bitpos */
complain_overflow_bitfield, /* complain_on_overflow */
cris_elf_pcrel_reloc, /* special_function */
"R_CRIS_32_PCREL", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0x00000000, /* src_mask */
0xffffffff, /* dst_mask */
- TRUE), /* pcrel_offset */
+ true), /* pcrel_offset */
/* GNU extension to record C++ vtable hierarchy. */
HOWTO (R_CRIS_GNU_VTINHERIT, /* type */
0, /* rightshift */
2, /* size (0 = byte, 1 = short, 2 = long) */
0, /* bitsize */
- FALSE, /* pc_relative */
+ false, /* pc_relative */
0, /* bitpos */
complain_overflow_dont, /* complain_on_overflow */
NULL, /* special_function */
"R_CRIS_GNU_VTINHERIT", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0, /* src_mask */
0, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
/* GNU extension to record C++ vtable member usage. */
HOWTO (R_CRIS_GNU_VTENTRY, /* type */
0, /* rightshift */
2, /* size (0 = byte, 1 = short, 2 = long) */
0, /* bitsize */
- FALSE, /* pc_relative */
+ false, /* pc_relative */
0, /* bitpos */
complain_overflow_dont, /* complain_on_overflow */
_bfd_elf_rel_vtable_reloc_fn, /* special_function */
"R_CRIS_GNU_VTENTRY", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0, /* src_mask */
0, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
/* This is used only by the dynamic linker. The symbol should exist
both in the object being run and in some shared library. The
0, /* rightshift */
2, /* size (0 = byte, 1 = short, 2 = long) */
32, /* bitsize */
- FALSE, /* pc_relative */
+ false, /* pc_relative */
0, /* bitpos */
complain_overflow_bitfield, /* complain_on_overflow */
bfd_elf_generic_reloc, /* special_function */
"R_CRIS_COPY", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0, /* src_mask */
0, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
/* Like R_CRIS_32, but used when setting global offset table entries. */
HOWTO (R_CRIS_GLOB_DAT, /* type */
0, /* rightshift */
2, /* size (0 = byte, 1 = short, 2 = long) */
32, /* bitsize */
- FALSE, /* pc_relative */
+ false, /* pc_relative */
0, /* bitpos */
complain_overflow_bitfield, /* complain_on_overflow */
bfd_elf_generic_reloc, /* special_function */
"R_CRIS_GLOB_DAT", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0, /* src_mask */
0xffffffff, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
/* Marks a procedure linkage table entry for a symbol. */
HOWTO (R_CRIS_JUMP_SLOT, /* type */
0, /* rightshift */
2, /* size (0 = byte, 1 = short, 2 = long) */
32, /* bitsize */
- FALSE, /* pc_relative */
+ false, /* pc_relative */
0, /* bitpos */
complain_overflow_bitfield, /* complain_on_overflow */
bfd_elf_generic_reloc, /* special_function */
"R_CRIS_JUMP_SLOT", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0, /* src_mask */
0, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
/* Used only by the dynamic linker. When the object is run, this
longword is set to the load address of the object, plus the
0, /* rightshift */
2, /* size (0 = byte, 1 = short, 2 = long) */
32, /* bitsize */
- FALSE, /* pc_relative */
+ false, /* pc_relative */
0, /* bitpos */
complain_overflow_bitfield, /* complain_on_overflow */
bfd_elf_generic_reloc, /* special_function */
"R_CRIS_RELATIVE", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0, /* src_mask */
0xffffffff, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
/* Like R_CRIS_32, but referring to the GOT table entry for the symbol. */
HOWTO (R_CRIS_16_GOT, /* type */
0, /* rightshift */
1, /* size (0 = byte, 1 = short, 2 = long) */
16, /* bitsize */
- FALSE, /* pc_relative */
+ false, /* pc_relative */
0, /* bitpos */
complain_overflow_bitfield, /* complain_on_overflow */
bfd_elf_generic_reloc, /* special_function */
"R_CRIS_16_GOT", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0, /* src_mask */
0xffff, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
HOWTO (R_CRIS_32_GOT, /* type */
0, /* rightshift */
2, /* size (0 = byte, 1 = short, 2 = long) */
32, /* bitsize */
- FALSE, /* pc_relative */
+ false, /* pc_relative */
0, /* bitpos */
complain_overflow_bitfield, /* complain_on_overflow */
bfd_elf_generic_reloc, /* special_function */
"R_CRIS_32_GOT", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0, /* src_mask */
0xffffffff, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
/* Like R_CRIS_32_GOT, but referring to (and requesting a) PLT part of
the GOT table for the symbol. */
0, /* rightshift */
1, /* size (0 = byte, 1 = short, 2 = long) */
16, /* bitsize */
- FALSE, /* pc_relative */
+ false, /* pc_relative */
0, /* bitpos */
complain_overflow_bitfield, /* complain_on_overflow */
bfd_elf_generic_reloc, /* special_function */
"R_CRIS_16_GOTPLT", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0, /* src_mask */
0xffff, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
HOWTO (R_CRIS_32_GOTPLT, /* type */
0, /* rightshift */
2, /* size (0 = byte, 1 = short, 2 = long) */
32, /* bitsize */
- FALSE, /* pc_relative */
+ false, /* pc_relative */
0, /* bitpos */
complain_overflow_bitfield, /* complain_on_overflow */
bfd_elf_generic_reloc, /* special_function */
"R_CRIS_32_GOTPLT", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0, /* src_mask */
0xffffffff, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
/* A 32-bit offset from GOT to (local const) symbol: no GOT entry should
be necessary. */
0, /* rightshift */
2, /* size (0 = byte, 1 = short, 2 = long) */
32, /* bitsize */
- FALSE, /* pc_relative */
+ false, /* pc_relative */
0, /* bitpos */
complain_overflow_bitfield, /* complain_on_overflow */
bfd_elf_generic_reloc, /* special_function */
"R_CRIS_32_GOTREL", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0, /* src_mask */
0xffffffff, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
/* A 32-bit offset from GOT to entry for this symbol in PLT and request
to create PLT entry for symbol. */
0, /* rightshift */
2, /* size (0 = byte, 1 = short, 2 = long) */
32, /* bitsize */
- FALSE, /* pc_relative */
+ false, /* pc_relative */
0, /* bitpos */
complain_overflow_bitfield, /* complain_on_overflow */
bfd_elf_generic_reloc, /* special_function */
"R_CRIS_32_PLT_GOTREL", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0, /* src_mask */
0xffffffff, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
/* A 32-bit offset from PC (location after the relocation) + addend to
entry for this symbol in PLT and request to create PLT entry for
0, /* rightshift */
2, /* size (0 = byte, 1 = short, 2 = long) */
32, /* bitsize */
- TRUE, /* pc_relative */
+ true, /* pc_relative */
0, /* bitpos */
complain_overflow_bitfield, /* complain_on_overflow */
cris_elf_pcrel_reloc, /* special_function */
"R_CRIS_32_PLT_PCREL", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0, /* src_mask */
0xffffffff, /* dst_mask */
- TRUE), /* pcrel_offset */
+ true), /* pcrel_offset */
/* We don't handle these in any special manner and cross-format
linking is not supported; just recognize them enough to pass them
tests to actually refuse gracefully to handle these and PIC
relocs for cross-format linking. */
#define TLSHOWTO32(name) \
- HOWTO (name, 0, 2, 32, FALSE, 0, complain_overflow_bitfield, \
- bfd_elf_generic_reloc, #name, FALSE, 0, 0xffffffff, FALSE)
+ HOWTO (name, 0, 2, 32, false, 0, complain_overflow_bitfield, \
+ bfd_elf_generic_reloc, #name, false, 0, 0xffffffff, false)
#define TLSHOWTO16X(name, X) \
- HOWTO (name, 0, 1, 16, FALSE, 0, complain_overflow_ ## X, \
- bfd_elf_generic_reloc, #name, FALSE, 0, 0xffff, FALSE)
+ HOWTO (name, 0, 1, 16, false, 0, complain_overflow_ ## X, \
+ bfd_elf_generic_reloc, #name, false, 0, 0xffff, false)
#define TLSHOWTO16(name) TLSHOWTO16X(name, unsigned)
#define TLSHOWTO16S(name) TLSHOWTO16X(name, signed)
/* Set the howto pointer for an CRIS ELF reloc. */
-static void
+static bool
cris_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED,
arelent * cache_ptr,
Elf_Internal_Rela * dst)
enum elf_cris_reloc_type r_type;
r_type = ELF32_R_TYPE (dst->r_info);
- BFD_ASSERT (r_type < (unsigned int) R_CRIS_max);
+ if (r_type >= R_CRIS_max)
+ {
+ /* 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 = & cris_elf_howto_table [r_type];
+ return true;
}
bfd_reloc_status_type
some similarities with other ports, hoping to simplify general
changes, while still keeping Linux/CRIS and Linux/CRISv32 code apart. */
-static bfd_boolean
+static bool
cris_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
{
int offset;
switch (note->descsz)
{
default:
- return FALSE;
+ return false;
case 202: /* Linux/CRISv32 */
/* pr_cursig */
switch (note->descsz)
{
default:
- return FALSE;
+ return false;
case 214: /* Linux/CRIS */
/* pr_cursig */
size, note->descpos + offset);
}
-static bfd_boolean
+static bool
cris_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
{
if (bfd_get_mach (abfd) == bfd_mach_cris_v32)
switch (note->descsz)
{
default:
- return FALSE;
+ return false;
case 124: /* Linux/CRISv32 elf_prpsinfo */
elf_tdata (abfd)->core->program
switch (note->descsz)
{
default:
- return FALSE;
+ return false;
case 124: /* Linux/CRIS elf_prpsinfo */
elf_tdata (abfd)->core->program
command[n - 1] = '\0';
}
- return TRUE;
+ return true;
}
\f
/* The name of the dynamic interpreter. This is put in the .interp
bfd_signed_vma dtp_refcount;
};
-static bfd_boolean
+static bool
elf_cris_discard_excess_dso_dynamics (struct elf_cris_link_hash_entry *,
void * );
-static bfd_boolean
+static bool
elf_cris_discard_excess_program_dynamics (struct elf_cris_link_hash_entry *,
void *);
#define elf_cris_link_hash_traverse(table, func, info) \
(elf_link_hash_traverse \
(&(table)->root, \
- (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
+ (bool (*) (struct elf_link_hash_entry *, void *)) (func), \
(info)))
/* Get the CRIS ELF linker hash table from a link_info structure. */
#define elf_cris_hash_table(p) \
- (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
- == CRIS_ELF_DATA ? ((struct elf_cris_link_hash_table *) ((p)->hash)) : NULL)
+ ((is_elf_hash_table ((p)->hash) \
+ && elf_hash_table_id (elf_hash_table (p)) == CRIS_ELF_DATA) \
+ ? (struct elf_cris_link_hash_table *) (p)->hash : NULL)
/* Get the CRIS ELF linker hash entry from a regular hash entry (the
"parent class"). The .root reference is just a simple type
elf_cris_link_hash_table_create (bfd *abfd)
{
struct elf_cris_link_hash_table *ret;
- bfd_size_type amt = sizeof (struct elf_cris_link_hash_table);
+ size_t amt = sizeof (struct elf_cris_link_hash_table);
ret = ((struct elf_cris_link_hash_table *) bfd_zmalloc (amt));
if (ret == (struct elf_cris_link_hash_table *) NULL)
static bfd_reloc_status_type
cris_final_link_relocate (reloc_howto_type * howto,
- bfd * input_bfd,
- asection * input_section,
- bfd_byte * contents,
+ bfd * input_bfd,
+ asection * input_section,
+ bfd_byte * contents,
Elf_Internal_Rela * rel,
- bfd_vma relocation)
+ bfd_vma relocation)
{
bfd_reloc_status_type r;
enum elf_cris_reloc_type r_type = ELF32_R_TYPE (rel->r_info);
/* Relocate an CRIS ELF section. See elf32-fr30.c, from where this was
copied, for further comments. */
-static bfd_boolean
+static int
cris_elf_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
struct bfd_link_info *info,
bfd *input_bfd,
htab = elf_cris_hash_table (info);
if (htab == NULL)
- return FALSE;
+ return false;
- dynobj = elf_hash_table (info)->dynobj;
+ dynobj = htab->root.dynobj;
local_got_offsets = elf_local_got_offsets (input_bfd);
symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
sym_hashes = elf_sym_hashes (input_bfd);
if (dynobj != NULL)
{
- splt = bfd_get_linker_section (dynobj, ".plt");
- sgot = bfd_get_linker_section (dynobj, ".got");
+ splt = htab->root.splt;
+ sgot = htab->root.sgot;
}
for (rel = relocs; rel < relend; rel ++)
bfd_reloc_status_type r;
const char *symname = NULL;
enum elf_cris_reloc_type r_type;
+ bool resolved_to_zero;
r_type = ELF32_R_TYPE (rel->r_info);
symname = (bfd_elf_string_from_elf_section
(input_bfd, symtab_hdr->sh_link, sym->st_name));
if (symname == NULL)
- symname = bfd_section_name (input_bfd, sec);
+ symname = bfd_section_name (sec);
}
else
{
- bfd_boolean warned, ignored;
- bfd_boolean unresolved_reloc;
+ bool warned, ignored;
+ bool unresolved_reloc;
RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
r_symndx, symtab_hdr, sym_hashes,
time. FIXME: Not sure this example covers the
h->elf_link_hash_flags test, though it's there in
other targets. */
- if (info->shared
- && ((! info->symbolic && h->dynindx != -1)
+ if (bfd_link_pic (info)
+ && ((!SYMBOLIC_BIND (info, h) && h->dynindx != -1)
|| !h->def_regular)
&& (input_section->flags & SEC_ALLOC) != 0
&& (r_type == R_CRIS_8
|| r_type == R_CRIS_16_PCREL
|| r_type == R_CRIS_32_PCREL))
relocation = 0;
- else if (!info->relocatable && unresolved_reloc
+ else if (!bfd_link_relocatable (info) && unresolved_reloc
&& (_bfd_elf_section_offset (output_bfd, info,
input_section,
rel->r_offset)
!= (bfd_vma) -1))
{
_bfd_error_handler
- (_("%B, section %A: unresolvable relocation %s against symbol `%s'"),
+ /* xgettext:c-format */
+ (_("%pB, section %pA: unresolvable relocation %s against symbol `%s'"),
input_bfd,
input_section,
cris_elf_howto_table[r_type].name,
symname);
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
}
}
RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
rel, 1, relend, howto, 0, contents);
- if (info->relocatable)
+ if (bfd_link_relocatable (info))
continue;
+ resolved_to_zero = (h != NULL
+ && UNDEFWEAK_NO_DYNAMIC_RELOC (info, h));
+
switch (r_type)
{
case R_CRIS_16_GOTPLT:
if (h != NULL
&& ((struct elf_cris_link_hash_entry *) h)->gotplt_offset != 0)
{
- asection *sgotplt
- = bfd_get_linker_section (dynobj, ".got.plt");
+ asection *sgotplt = htab->root.sgotplt;
bfd_vma got_offset;
BFD_ASSERT (h->dynindx != -1);
these call-specific relocs don't address non-functions. */
if (h != NULL
&& (h->got.offset == (bfd_vma) -1
- || (!info->shared
+ || (!bfd_link_pic (info)
&& !(h->def_regular
|| (!h->def_dynamic
&& h->root.type == bfd_link_hash_undefweak)))))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
((h->got.offset == (bfd_vma) -1)
- ? _("%B, section %A: No PLT nor GOT for relocation %s"
+ /* xgettext:c-format */
+ ? _("%pB, section %pA: no PLT nor GOT for relocation %s"
" against symbol `%s'")
- : _("%B, section %A: No PLT for relocation %s"
+ /* xgettext:c-format */
+ : _("%pB, section %pA: no PLT for relocation %s"
" against symbol `%s'"),
input_bfd,
input_section,
do; this is probably an internal error. But it is true
that we didn't like that particular input. */
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
/* Fall through. */
BFD_ASSERT (off != (bfd_vma) -1);
if (!elf_hash_table (info)->dynamic_sections_created
- || (! info->shared
+ || (! bfd_link_pic (info)
&& (h->def_regular
|| h->type == STT_FUNC
|| h->needs_plt))
- || (info->shared
- && (info->symbolic || h->dynindx == -1)
+ || (bfd_link_pic (info)
+ && (SYMBOLIC_BIND (info, h) || h->dynindx == -1)
&& h->def_regular))
{
- /* This wasn't checked above for ! info->shared, but
+ /* This wasn't checked above for ! bfd_link_pic (info), but
must hold there if we get here; the symbol must
be defined in the regular program or be undefweak
or be a function or otherwise need a PLT. */
BFD_ASSERT (!elf_hash_table (info)->dynamic_sections_created
- || info->shared
+ || bfd_link_pic (info)
|| h->def_regular
|| h->type == STT_FUNC
|| h->needs_plt
{
bfd_put_32 (output_bfd, relocation, sgot->contents + off);
- if (info->shared)
+ if (bfd_link_pic (info))
{
Elf_Internal_Rela outrel;
bfd_byte *loc;
- if (srelgot == NULL)
- srelgot
- = bfd_get_linker_section (dynobj, ".rela.got");
+ srelgot = htab->root.srelgot;
BFD_ASSERT (srelgot != NULL);
outrel.r_offset = (sgot->output_section->vma
symbols. Make this an error; the compiler isn't
allowed to pass us these kinds of things. */
if (h == NULL)
- (*_bfd_error_handler)
- (_("%B, section %A: relocation %s with non-zero addend %d"
- " against local symbol"),
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB, section %pA: relocation %s with non-zero addend"
+ " %" PRId64 " against local symbol"),
input_bfd,
input_section,
cris_elf_howto_table[r_type].name,
- rel->r_addend);
+ (int64_t) rel->r_addend);
else
- (*_bfd_error_handler)
- (_("%B, section %A: relocation %s with non-zero addend %d"
- " against symbol `%s'"),
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB, section %pA: relocation %s with non-zero addend"
+ " %" PRId64 " against symbol `%s'"),
input_bfd,
input_section,
cris_elf_howto_table[r_type].name,
- rel->r_addend,
+ (int64_t) rel->r_addend,
symname[0] != '\0' ? symname : _("[whose name is lost]"));
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
}
break;
defined in an ordinary (non-DSO) object or is undefined weak. */
if (h != NULL
&& ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
- && !(!info->shared
+ && !(!bfd_link_pic (info)
&& (h->def_regular
|| (!h->def_dynamic
&& h->root.type == bfd_link_hash_undefweak))))
{
- (*_bfd_error_handler)
- (_("%B, section %A: relocation %s is"
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB, section %pA: relocation %s is"
" not allowed for global symbol: `%s'"),
input_bfd,
input_section,
cris_elf_howto_table[r_type].name,
symname);
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
/* This can happen if we get a link error with the input ELF
it's noticed if it happens elsewhere. */
if (sgot == NULL)
{
- (*_bfd_error_handler)
- (_("%B, section %A: relocation %s with no GOT created"),
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB, section %pA: relocation %s with no GOT created"),
input_bfd,
input_section,
cris_elf_howto_table[r_type].name);
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
/* This relocation is like a PC-relative one, except the
case R_CRIS_8:
case R_CRIS_16:
case R_CRIS_32:
- if (info->shared
+ if (bfd_link_pic (info)
+ && !resolved_to_zero
&& r_symndx != STN_UNDEF
&& (input_section->flags & SEC_ALLOC) != 0
&& ((r_type != R_CRIS_8_PCREL
&& r_type != R_CRIS_16_PCREL
&& r_type != R_CRIS_32_PCREL)
- || (!info->symbolic
+ || (!SYMBOLIC_BIND (info, h)
|| (h != NULL && !h->def_regular))))
{
Elf_Internal_Rela outrel;
bfd_byte *loc;
- bfd_boolean skip, relocate;
+ bool skip, relocate;
/* When generating a shared object, these relocations
are copied into the output file to be resolved at run
if (sreloc == NULL)
{
sreloc = _bfd_elf_get_dynamic_reloc_section
- (dynobj, input_section, /*rela?*/ TRUE);
+ (dynobj, input_section, /*rela?*/ true);
/* The section should have been created in cris_elf_check_relocs,
but that function will not be called for objects which fail in
cris_elf_merge_private_bfd_data. */
if (sreloc == NULL)
{
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
}
- skip = FALSE;
- relocate = FALSE;
+ skip = false;
+ relocate = false;
outrel.r_offset =
_bfd_elf_section_offset (output_bfd, info, input_section,
rel->r_offset);
if (outrel.r_offset == (bfd_vma) -1)
- skip = TRUE;
+ skip = true;
else if (outrel.r_offset == (bfd_vma) -2
/* For now, undefined weak symbols with non-default
visibility (yielding 0), like exception info for
|| (h != NULL
&& h->root.type == bfd_link_hash_undefweak
&& ELF_ST_VISIBILITY (h->other) != STV_DEFAULT))
- skip = TRUE, relocate = TRUE;
+ skip = true, relocate = true;
outrel.r_offset += (input_section->output_section->vma
+ input_section->output_offset);
/* h->dynindx may be -1 if the symbol was marked to
become local. */
else if (h != NULL
- && ((! info->symbolic && h->dynindx != -1)
+ && ((!SYMBOLIC_BIND (info, h) && h->dynindx != -1)
|| !h->def_regular))
{
BFD_ASSERT (h->dynindx != -1);
if (r_type == R_CRIS_32)
{
- relocate = TRUE;
+ relocate = true;
outrel.r_info = ELF32_R_INFO (0, R_CRIS_RELATIVE);
}
else
else if (sec == NULL || sec->owner == NULL)
{
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
else
{
bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
/* This reloc will be computed at runtime, so there's no
- need to do anything now, except for R_CRIS_32 relocations
- that have been turned into R_CRIS_RELATIVE. */
+ need to do anything now, except for R_CRIS_32 relocations
+ that have been turned into R_CRIS_RELATIVE. */
if (!relocate)
continue;
}
if (h != NULL
&& (input_section->flags & SEC_ALLOC) != 0
&& ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
- && (info->shared
+ && (bfd_link_pic (info)
|| (!h->def_regular
&& h->root.type != bfd_link_hash_undefined)))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
((h->root.type == bfd_link_hash_undefined)
/* We shouldn't get here for GCC-emitted code. */
- ? _("%B, section %A: relocation %s has an undefined"
+ /* xgettext:c-format */
+ ? _("%pB, section %pA: relocation %s has an undefined"
" reference to `%s', perhaps a declaration mixup?")
- : ("%B, section %A: relocation %s is"
+ /* xgettext:c-format */
+ : _("%pB, section %pA: relocation %s is"
" not allowed for `%s', a global symbol with default"
" visibility, perhaps a declaration mixup?"),
input_bfd,
symname != NULL && symname[0] != '\0'
? symname : _("[whose name is lost]"));
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
BFD_ASSERT ((input_section->flags & SEC_ALLOC) == 0
if (htab->dtpmod_refcount > 0
&& (input_section->flags & SEC_ALLOC) != 0)
{
- asection *sgotplt = bfd_get_linker_section (dynobj, ".got.plt");
+ asection *sgotplt = htab->root.sgotplt;
BFD_ASSERT (sgotplt != NULL);
- if (info->shared)
+ if (bfd_link_pic (info))
{
Elf_Internal_Rela outrel;
bfd_byte *loc;
- if (srelgot == NULL)
- srelgot = bfd_get_linker_section (dynobj, ".rela.got");
+ srelgot = htab->root.srelgot;
BFD_ASSERT (srelgot != NULL);
loc = srelgot->contents;
loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
break;
case R_CRIS_32_GD:
- if (info->shared)
+ if (bfd_link_pic (info))
{
bfd_set_error (bfd_error_invalid_operation);
/* We've already informed in cris_elf_check_relocs that
this is an error. */
- return FALSE;
+ return false;
}
/* Fall through. */
symbol *plus offset*. The GOT holds relocations for
symbols. Make this an error; the compiler isn't allowed
to pass us these kinds of things. */
- (*_bfd_error_handler)
- (_("%B, section %A: relocation %s with non-zero addend %d"
- " against symbol `%s'"),
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB, section %pA: relocation %s with non-zero addend"
+ " %" PRId64 " against symbol `%s'"),
input_bfd,
input_section,
cris_elf_howto_table[r_type].name,
- rel->r_addend,
+ (int64_t) rel->r_addend,
symname[0] != '\0' ? symname : _("[whose name is lost]"));
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
- if (!info->shared
+ if (!bfd_link_pic (info)
&& (h == NULL || h->def_regular || ELF_COMMON_DEF_P (h)))
{
/* Known contents of the GOT. */
bfd_put_32 (output_bfd, 0, sgot->contents + off);
bfd_put_32 (output_bfd, 0, sgot->contents + off + 4);
- if (srelgot == NULL)
- srelgot = bfd_get_linker_section (dynobj, ".rela.got");
+ srelgot = htab->root.srelgot;
BFD_ASSERT (srelgot != NULL);
if (h != NULL && h->dynindx != -1)
break;
case R_CRIS_32_IE:
- if (info->shared)
+ if (bfd_link_pic (info))
{
bfd_set_error (bfd_error_invalid_operation);
/* We've already informed in cris_elf_check_relocs that
this is an error. */
- return FALSE;
+ return false;
}
/* Fall through. */
relocations for symbols. Make this an error; the
compiler isn't allowed to pass us these kinds of
things. */
- (*_bfd_error_handler)
- (_("%B, section %A: relocation %s with non-zero addend %d"
- " against symbol `%s'"),
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB, section %pA: relocation %s with non-zero addend"
+ " %" PRId64 " against symbol `%s'"),
input_bfd,
input_section,
cris_elf_howto_table[r_type].name,
- rel->r_addend,
+ (int64_t) rel->r_addend,
symname[0] != '\0' ? symname : _("[whose name is lost]"));
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
- if (!info->shared
+ if (!bfd_link_pic (info)
&& (h == NULL || h->def_regular || ELF_COMMON_DEF_P (h)))
{
/* Known contents of the GOT. */
else
local_got_offsets[r_symndx] |= 1;
- if (srelgot == NULL)
- srelgot = bfd_get_linker_section (dynobj, ".rela.got");
+ srelgot = htab->root.srelgot;
BFD_ASSERT (srelgot != NULL);
if (h != NULL && h->dynindx != -1)
case R_CRIS_32_TPREL:
/* This relocation must only be performed against symbols
defined in an ordinary (non-DSO) object. */
- if (info->shared)
+ if (bfd_link_pic (info))
{
bfd_set_error (bfd_error_invalid_operation);
/* We've already informed in cris_elf_check_relocs that
this is an error. */
- return FALSE;
+ return false;
}
if (h != NULL
been emitted. */
&& h->root.type != bfd_link_hash_undefined)
{
- (*_bfd_error_handler)
- (_("%B, section %A: relocation %s is"
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB, section %pA: relocation %s is"
" not allowed for symbol: `%s'"
" which is defined outside the program,"
" perhaps a declaration mixup?"),
cris_elf_howto_table[r_type].name,
symname);
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
/* NULL if we had an error. */
default:
BFD_FAIL ();
- return FALSE;
+ return false;
}
r = cris_final_link_relocate (howto, input_bfd, input_section,
switch (r)
{
case bfd_reloc_overflow:
- r = info->callbacks->reloc_overflow
+ (*info->callbacks->reloc_overflow)
(info, (h ? &h->root : NULL), symname, howto->name,
(bfd_vma) 0, input_bfd, input_section, rel->r_offset);
if (additional_relocation_error_msg_count > 0)
only. */
case R_CRIS_16_GOT_TPREL:
case R_CRIS_16_GOT_GD:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("(too many global variables for -fpic:"
" recompile with -fPIC)"));
break;
case R_CRIS_16_TPREL:
case R_CRIS_16_DTPREL:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("(thread-local data too big for -fpic or"
" -msmall-tls: recompile with -fPIC or"
" -mno-small-tls)"));
break;
case bfd_reloc_undefined:
- r = info->callbacks->undefined_symbol
- (info, symname, input_bfd, input_section, rel->r_offset,
- TRUE);
+ (*info->callbacks->undefined_symbol)
+ (info, symname, input_bfd, input_section, rel->r_offset, true);
break;
case bfd_reloc_outofrange:
}
if (msg)
- r = info->callbacks->warning
- (info, msg, symname, input_bfd, input_section, rel->r_offset);
-
- if (! r)
- return FALSE;
+ (*info->callbacks->warning) (info, msg, symname, input_bfd,
+ input_section, rel->r_offset);
}
}
- return TRUE;
+ return true;
}
\f
/* Finish up dynamic symbol handling. We set the contents of various
dynamic sections here. */
-static bfd_boolean
+static bool
elf_cris_finish_dynamic_symbol (bfd *output_bfd,
struct bfd_link_info *info,
struct elf_link_hash_entry *h,
Elf_Internal_Sym *sym)
{
struct elf_cris_link_hash_table * htab;
- bfd *dynobj;
/* Where in the plt entry to put values. */
int plt_off1 = 2, plt_off2 = 10, plt_off3 = 16;
htab = elf_cris_hash_table (info);
if (htab == NULL)
- return FALSE;
+ return false;
/* Adjust the various PLT entry offsets. */
if (bfd_get_mach (output_bfd) == bfd_mach_cris_v32)
plt_pic_entry = elf_cris_pic_plt_entry_v32;
}
- dynobj = elf_hash_table (info)->dynobj;
-
if (h->plt.offset != (bfd_vma) -1)
{
asection *splt;
= elf_cris_hash_entry (h)->gotplt_offset;
Elf_Internal_Rela rela;
bfd_byte *loc;
- bfd_boolean has_gotplt = gotplt_offset != 0;
+ bool has_gotplt = gotplt_offset != 0;
/* Get the index in the .rela.plt relocations for the .got.plt
entry that corresponds to this symbol.
BFD_ASSERT (h->dynindx != -1);
- splt = bfd_get_linker_section (dynobj, ".plt");
- sgotplt = bfd_get_linker_section (dynobj, ".got.plt");
- srela = bfd_get_linker_section (dynobj, ".rela.plt");
+ splt = htab->root.splt;
+ sgotplt = htab->root.sgotplt;
+ srela = htab->root.srelplt;
BFD_ASSERT (splt != NULL && sgotplt != NULL
&& (! has_gotplt || srela != NULL));
got_base = sgotplt->output_section->vma + sgotplt->output_offset;
/* Fill in the entry in the procedure linkage table. */
- if (! info->shared)
+ if (! bfd_link_pic (info))
{
memcpy (splt->contents + h->plt.offset, plt_entry,
plt_entry_size);
references to the function symbol are redirected to the PLT. */
if (h->got.offset != (bfd_vma) -1
&& (elf_cris_hash_entry (h)->reg_got_refcount > 0)
- && (info->shared
+ && (bfd_link_pic (info)
|| (h->dynindx != -1
&& h->plt.offset == (bfd_vma) -1
&& !h->def_regular
/* This symbol has an entry in the global offset table. Set it up. */
- sgot = bfd_get_linker_section (dynobj, ".got");
- srela = bfd_get_linker_section (dynobj, ".rela.got");
+ sgot = htab->root.sgot;
+ srela = htab->root.srelgot;
BFD_ASSERT (sgot != NULL && srela != NULL);
rela.r_offset = (sgot->output_section->vma
initialized in the relocate_section function. */
where = sgot->contents + (h->got.offset &~ (bfd_vma) 1);
if (! elf_hash_table (info)->dynamic_sections_created
- || (info->shared
- && (info->symbolic || h->dynindx == -1)
+ || (bfd_link_pic (info)
+ && (SYMBOLIC_BIND (info, h) || h->dynindx == -1)
&& h->def_regular))
{
rela.r_info = ELF32_R_INFO (0, R_CRIS_RELATIVE);
&& (h->root.type == bfd_link_hash_defined
|| h->root.type == bfd_link_hash_defweak));
- s = bfd_get_linker_section (dynobj, ".rela.bss");
- BFD_ASSERT (s != NULL);
+ if (h->root.u.def.section == htab->root.sdynrelro)
+ s = htab->root.sreldynrelro;
+ else
+ s = htab->root.srelbss;
rela.r_offset = (h->root.u.def.value
+ h->root.u.def.section->output_section->vma
|| h == elf_hash_table (info)->hgot)
sym->st_shndx = SHN_ABS;
- return TRUE;
+ return true;
}
\f
/* Finish up the dynamic sections. Do *not* emit relocs here, as their
offsets were changed, as part of -z combreloc handling, from those we
computed. */
-static bfd_boolean
+static bool
elf_cris_finish_dynamic_sections (bfd *output_bfd,
struct bfd_link_info *info)
{
dynobj = elf_hash_table (info)->dynobj;
- sgot = bfd_get_linker_section (dynobj, ".got.plt");
+ sgot = elf_hash_table (info)->sgotplt;
BFD_ASSERT (sgot != NULL);
sdyn = bfd_get_linker_section (dynobj, ".dynamic");
asection *splt;
Elf32_External_Dyn *dyncon, *dynconend;
- splt = bfd_get_linker_section (dynobj, ".plt");
+ splt = elf_hash_table (info)->splt;
BFD_ASSERT (splt != NULL && sdyn != NULL);
dyncon = (Elf32_External_Dyn *) sdyn->contents;
break;
case DT_PLTGOT:
- s = bfd_get_section_by_name (output_bfd, ".got");
- BFD_ASSERT (s != NULL);
- dyn.d_un.d_ptr = s->vma;
+ dyn.d_un.d_ptr = sgot->output_section->vma + sgot->output_offset;
bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
break;
case DT_JMPREL:
/* Yes, we *can* have a .plt and no .plt.rela, for instance
if all symbols are found in the .got (not .got.plt). */
- s = bfd_get_section_by_name (output_bfd, ".rela.plt");
- dyn.d_un.d_ptr = s != NULL ? s->vma : 0;
+ s = elf_hash_table (info)->srelplt;
+ dyn.d_un.d_ptr = s != NULL ? (s->output_section->vma
+ + s->output_offset) : 0;
bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
break;
case DT_PLTRELSZ:
- s = bfd_get_section_by_name (output_bfd, ".rela.plt");
+ s = elf_hash_table (info)->srelplt;
if (s == NULL)
dyn.d_un.d_val = 0;
else
dyn.d_un.d_val = s->size;
bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
break;
-
- case DT_RELASZ:
- /* The procedure linkage table relocs (DT_JMPREL) should
- not be included in the overall relocs (DT_RELA).
- Therefore, we override the DT_RELASZ entry here to
- make it not include the JMPREL relocs. Since the
- linker script arranges for .rela.plt to follow all
- other relocation sections, we don't have to worry
- about changing the DT_RELA entry. */
- s = bfd_get_section_by_name (output_bfd, ".rela.plt");
- if (s != NULL)
- dyn.d_un.d_val -= s->size;
- bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
- break;
}
}
{
if (bfd_get_mach (output_bfd) == bfd_mach_cris_v32)
{
- if (info->shared)
+ if (bfd_link_pic (info))
memcpy (splt->contents, elf_cris_pic_plt0_entry_v32,
PLT_ENTRY_SIZE_V32);
else
}
else
{
- if (info->shared)
+ if (bfd_link_pic (info))
memcpy (splt->contents, elf_cris_pic_plt0_entry,
PLT_ENTRY_SIZE);
else
elf_section_data (splt->output_section)->this_hdr.sh_entsize
= PLT_ENTRY_SIZE;
}
- }
+ }
}
}
elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
- return TRUE;
+ return true;
}
\f
/* Return the section that should be marked against GC for a given
return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
}
-/* Update the got entry reference counts for the section being removed. */
-
-static bfd_boolean
-cris_elf_gc_sweep_hook (bfd *abfd,
- struct bfd_link_info *info,
- asection *sec,
- const Elf_Internal_Rela *relocs)
-{
- struct elf_cris_link_hash_table * htab;
- Elf_Internal_Shdr *symtab_hdr;
- struct elf_link_hash_entry **sym_hashes;
- bfd_signed_vma *local_got_refcounts;
- const Elf_Internal_Rela *rel, *relend;
- bfd *dynobj;
- asection *sgot;
- asection *srelgot;
-
- if (info->relocatable)
- return TRUE;
-
- dynobj = elf_hash_table (info)->dynobj;
- if (dynobj == NULL)
- return TRUE;
-
- htab = elf_cris_hash_table (info);
- if (htab == NULL)
- return FALSE;
-
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
- sym_hashes = elf_sym_hashes (abfd);
- local_got_refcounts = elf_local_got_refcounts (abfd);
-
- sgot = bfd_get_linker_section (dynobj, ".got");
- srelgot = bfd_get_linker_section (dynobj, ".rela.got");
-
- relend = relocs + sec->reloc_count;
- for (rel = relocs; rel < relend; rel++)
- {
- unsigned long r_symndx;
- struct elf_link_hash_entry *h = NULL;
- bfd_signed_vma got_element_size = 4;
- bfd_signed_vma *specific_refcount = NULL;
- enum elf_cris_reloc_type r_type;
-
- r_symndx = ELF32_R_SYM (rel->r_info);
- if (r_symndx >= symtab_hdr->sh_info)
- {
- 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;
- }
-
- r_type = ELF32_R_TYPE (rel->r_info);
- switch (r_type)
- {
- case R_CRIS_32_GOT:
- case R_CRIS_16_GOT:
- case R_CRIS_16_GOTPLT:
- case R_CRIS_32_GOTPLT:
- specific_refcount = h != NULL
- ? &((struct elf_cris_link_hash_entry *) h)->reg_got_refcount
- : &local_got_refcounts[LGOT_REG_NDX (r_symndx)];
- break;
-
- case R_CRIS_32_GD:
- case R_CRIS_32_GOT_GD:
- case R_CRIS_16_GOT_GD:
- got_element_size = 8;
- specific_refcount = h != NULL
- ? &((struct elf_cris_link_hash_entry *) h)->dtp_refcount
- : &local_got_refcounts[LGOT_DTP_NDX (r_symndx)];
- break;
-
- case R_CRIS_32_IE:
- case R_CRIS_16_GOT_TPREL:
- case R_CRIS_32_GOT_TPREL:
- specific_refcount = h != NULL
- ? &((struct elf_cris_link_hash_entry *) h)->tprel_refcount
- : &local_got_refcounts[LGOT_TPREL_NDX (r_symndx)];
- break;
-
- default:
- break;
- }
-
- switch (r_type)
- {
- case R_CRIS_32_IE:
- case R_CRIS_32_GD:
- case R_CRIS_16_GOT_TPREL:
- case R_CRIS_32_GOT_TPREL:
- case R_CRIS_32_GOT_GD:
- case R_CRIS_16_GOT_GD:
- case R_CRIS_16_GOT:
- case R_CRIS_32_GOT:
- if (h != NULL)
- {
- /* If the counters are 0 when we got here, we've
- miscounted somehow somewhere, an internal error. */
- BFD_ASSERT (h->got.refcount > 0);
- --h->got.refcount;
-
- BFD_ASSERT (*specific_refcount > 0);
- --*specific_refcount;
- if (*specific_refcount == 0)
- {
- /* We don't need the .got entry any more. */
- sgot->size -= got_element_size;
- srelgot->size -= sizeof (Elf32_External_Rela);
- }
- break;
- }
-
- local_got_reloc:
- if (local_got_refcounts != NULL)
- {
- /* If the counters are 0 when we got here, we've
- miscounted somehow somewhere, an internal error. */
- BFD_ASSERT (local_got_refcounts[r_symndx] > 0);
- --local_got_refcounts[r_symndx];
-
- BFD_ASSERT (*specific_refcount > 0);
- --*specific_refcount;
- if (*specific_refcount == 0)
- {
- /* We don't need the .got entry any more. */
- sgot->size -= got_element_size;
- if (info->shared)
- srelgot->size -= sizeof (Elf32_External_Rela);
- }
- }
- break;
-
- case R_CRIS_16_GOTPLT:
- case R_CRIS_32_GOTPLT:
- /* For local symbols, treat these like GOT relocs. */
- if (h == NULL)
- goto local_got_reloc;
- else
- /* For global symbols, adjust the reloc-specific refcount. */
- elf_cris_hash_entry (h)->gotplt_refcount--;
- /* Fall through. */
-
- case R_CRIS_32_PLT_GOTREL:
- /* FIXME: We don't garbage-collect away the .got section. */
- if (local_got_refcounts != NULL)
- local_got_refcounts[-1]--;
- /* Fall through. */
-
- case R_CRIS_8:
- case R_CRIS_16:
- case R_CRIS_32:
- case R_CRIS_8_PCREL:
- case R_CRIS_16_PCREL:
- case R_CRIS_32_PCREL:
- case R_CRIS_32_PLT_PCREL:
- /* Negate the increment we did in cris_elf_check_relocs. */
- if (h != NULL)
- {
- if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
- && h->plt.refcount > 0)
- --h->plt.refcount;
- }
- break;
-
- case R_CRIS_32_DTPREL:
- /* This'd be a .dtpreld entry in e.g. debug info. */
- if ((sec->flags & SEC_ALLOC) == 0)
- break;
- /* Fall through. */
- case R_CRIS_16_DTPREL:
- htab->dtpmod_refcount--;
- if (htab->dtpmod_refcount == 0)
- htab->next_gotplt_entry -= 8;
- BFD_ASSERT (local_got_refcounts != NULL);
- local_got_refcounts[-1]--;
- break;
-
- default:
- break;
- }
- }
-
- return TRUE;
-}
-
/* The elf_backend_plt_sym_val hook function. */
static bfd_vma
if ((got = bfd_get_section_by_name (abfd, ".got")) == NULL)
return (bfd_vma) -1;
- plt_sec_size = bfd_section_size (plt->owner, plt);
+ plt_sec_size = bfd_section_size (plt);
plt_entry_size
= (bfd_get_mach (abfd) == bfd_mach_cris_v32
? PLT_ENTRY_SIZE_V32 : PLT_ENTRY_SIZE);
or elf_cris_size_dynamic_sections if no dynamic sections will be
created (we're only linking static objects). */
-static bfd_boolean
+static bool
elf_cris_adjust_gotplt_to_got (struct elf_cris_link_hash_entry *h, void * p)
{
struct bfd_link_info *info = (struct bfd_link_info *) p;
/* A GOTPLT reloc, when activated, is supposed to be included into
- the PLT refcount. */
+ the PLT refcount, when the symbol isn't set-or-forced local. */
BFD_ASSERT (h->gotplt_refcount == 0
+ || h->root.plt.refcount == -1
|| h->gotplt_refcount <= h->root.plt.refcount);
/* If nobody wanted a GOTPLT with this symbol, we're done. */
if (h->gotplt_refcount <= 0)
- return TRUE;
+ return true;
if (h->reg_got_refcount > 0)
{
else
{
/* No GOT entry for this symbol. We need to create one. */
- bfd *dynobj = elf_hash_table (info)->dynobj;
asection *sgot;
asection *srelgot;
- BFD_ASSERT (dynobj != NULL);
- sgot = bfd_get_linker_section (dynobj, ".got");
- srelgot = bfd_get_linker_section (dynobj, ".rela.got");
+ sgot = elf_hash_table (info)->sgot;
+ srelgot = elf_hash_table (info)->srelgot;
/* Put accurate refcounts there. */
+ BFD_ASSERT (h->root.got.refcount >= 0);
h->root.got.refcount += h->gotplt_refcount;
h->reg_got_refcount = h->gotplt_refcount;
srelgot->size += sizeof (Elf32_External_Rela);
}
- return TRUE;
+ return true;
}
/* Try to fold PLT entries with GOT entries. There are two cases when we
version scripts. The differing cases are handled by
elf_cris_hide_symbol. */
-static bfd_boolean
+static bool
elf_cris_try_fold_plt_to_got (struct elf_cris_link_hash_entry *h, void * p)
{
struct bfd_link_info *info = (struct bfd_link_info *) p;
other reference so there's nothing to do. Likewise if there are no
PLT references; GOTPLT references included. */
if (h->root.got.refcount <= 0 || h->root.plt.refcount <= 0)
- return TRUE;
+ return true;
/* GOTPLT relocs are supposed to be included into the PLT refcount. */
BFD_ASSERT (h->gotplt_refcount <= h->root.plt.refcount);
/* The only PLT references are GOTPLT references, and there are GOT
references. Convert PLT to GOT references. */
if (! elf_cris_adjust_gotplt_to_got (h, info))
- return FALSE;
+ return false;
/* Clear the PLT references, so no PLT will be created. */
h->root.plt.offset = (bfd_vma) -1;
}
- return TRUE;
+ return true;
}
/* Our own version of hide_symbol, so that we can adjust a GOTPLT reloc
static void
elf_cris_hide_symbol (struct bfd_link_info *info,
struct elf_link_hash_entry *h,
- bfd_boolean force_local)
+ bool force_local)
{
elf_cris_adjust_gotplt_to_got ((struct elf_cris_link_hash_entry *) h, info);
change the definition to something the rest of the link can
understand. */
-static bfd_boolean
+static bool
elf_cris_adjust_dynamic_symbol (struct bfd_link_info *info,
struct elf_link_hash_entry *h)
{
struct elf_cris_link_hash_table * htab;
bfd *dynobj;
asection *s;
+ asection *srel;
bfd_size_type plt_entry_size;
htab = elf_cris_hash_table (info);
if (htab == NULL)
- return FALSE;
+ return false;
- dynobj = elf_hash_table (info)->dynobj;
+ dynobj = htab->root.dynobj;
/* Make sure we know what is going on here. */
BFD_ASSERT (dynobj != NULL
&& (h->needs_plt
- || h->u.weakdef != NULL
+ || h->is_weakalias
|| (h->def_dynamic
&& h->ref_regular
&& !h->def_regular)));
result as one built without -fpic, specifically considering weak
symbols.
FIXME: m68k and i386 differ here, for unclear reasons. */
- if (! info->shared
+ if (! bfd_link_pic (info)
&& !h->def_dynamic)
{
/* This case can occur if we saw a PLT reloc in an input file,
like R_CRIS_JUMP_SLOT after symbol evaluation) we could get rid
of the PLT. We can't for the executable, because the GOT
entries will point to the PLT there (and be constant). */
- if (info->shared
+ if (bfd_link_pic (info)
&& !elf_cris_try_fold_plt_to_got ((struct elf_cris_link_hash_entry*)
h, info))
- return FALSE;
+ return false;
/* GC or folding may have rendered this entry unused. */
if (h->plt.refcount <= 0)
{
h->needs_plt = 0;
h->plt.offset = (bfd_vma) -1;
- return TRUE;
+ return true;
}
/* Make sure this symbol is output as a dynamic symbol. */
if (h->dynindx == -1)
{
if (! bfd_elf_link_record_dynamic_symbol (info, h))
- return FALSE;
+ return false;
}
- s = bfd_get_linker_section (dynobj, ".plt");
+ s = htab->root.splt;
BFD_ASSERT (s != NULL);
/* If this is the first .plt entry, make room for the special
/* If this symbol is not defined in a regular file, and we are
not generating a shared library, then set the symbol to this
location in the .plt. */
- if (!info->shared
+ if (!bfd_link_pic (info)
&& !h->def_regular)
{
h->root.u.def.section = s;
executable, because then the reloc associated with the PLT
would get a non-PLT reloc pointing to the PLT. FIXME: Move
this to elf_cris_try_fold_plt_to_got. */
- if (info->shared && h->got.refcount > 0)
+ if (bfd_link_pic (info) && h->got.refcount > 0)
{
h->got.refcount += h->plt.refcount;
/* Make room for this entry. */
s->size += plt_entry_size;
- return TRUE;
+ return true;
}
/* No GOT reference for this symbol; prepare for an ordinary PLT. */
= htab->next_gotplt_entry;
htab->next_gotplt_entry += 4;
- s = bfd_get_linker_section (dynobj, ".got.plt");
+ s = htab->root.sgotplt;
BFD_ASSERT (s != NULL);
s->size += 4;
/* We also need to make an entry in the .rela.plt section. */
- s = bfd_get_linker_section (dynobj, ".rela.plt");
+ s = htab->root.srelplt;
BFD_ASSERT (s != NULL);
s->size += sizeof (Elf32_External_Rela);
- return TRUE;
+ return true;
}
/* Reinitialize the plt offset now that it is not used as a reference
/* 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;
}
/* This is a reference to a symbol defined by a dynamic object which
only references to the symbol are via the global offset table.
For such cases we need not do anything here; the relocations will
be handled correctly by relocate_section. */
- if (info->shared)
- return TRUE;
+ if (bfd_link_pic (info))
+ return true;
/* If there are no references to this symbol that do not use the
GOT, we don't need to generate a copy reloc. */
if (!h->non_got_ref)
- return TRUE;
+ return true;
/* We must allocate the symbol in our .dynbss section, which will
become part of the .bss section of the executable. There will be
both the dynamic object and the regular object will refer to the
same memory location for the variable. */
- s = bfd_get_linker_section (dynobj, ".dynbss");
- BFD_ASSERT (s != NULL);
-
/* We must generate a R_CRIS_COPY reloc to tell the dynamic linker to
copy the initial value out of the dynamic object and into the
runtime process image. We need to remember the offset into the
.rela.bss section we are going to use. */
+
+ if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
+ {
+ s = htab->root.sdynrelro;
+ srel = htab->root.sreldynrelro;
+ }
+ else
+ {
+ s = htab->root.sdynbss;
+ srel = htab->root.srelbss;
+ }
if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
{
- asection *srel;
-
- srel = bfd_get_linker_section (dynobj, ".rela.bss");
BFD_ASSERT (srel != NULL);
srel->size += sizeof (Elf32_External_Rela);
h->needs_copy = 1;
}
+ BFD_ASSERT (s != NULL);
+
return _bfd_elf_adjust_dynamic_copy (info, h, s);
}
/* Look through the relocs for a section during the first phase. */
-static bfd_boolean
+static bool
cris_elf_check_relocs (bfd *abfd,
struct bfd_link_info *info,
asection *sec,
asection *srelgot;
asection *sreloc;
- if (info->relocatable)
- return TRUE;
+ if (bfd_link_relocatable (info))
+ return true;
htab = elf_cris_hash_table (info);
if (htab == NULL)
- return FALSE;
+ return false;
dynobj = elf_hash_table (info)->dynobj;
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
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;
}
r_type = ELF32_R_TYPE (rel->r_info);
that, we must insist on dynobj being a specific mach. */
if (bfd_get_mach (dynobj) == bfd_mach_cris_v10_v32)
{
- (*_bfd_error_handler)
- (_("%B, section %A:\n v10/v32 compatible object %s"
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB, section %pA: v10/v32 compatible object"
" must not contain a PIC relocation"),
abfd, sec);
- return FALSE;
+ return false;
}
}
can assume it's always present whenever there's a dynobj.
It's ok to call this function more than once. */
if (!_bfd_elf_create_got_section (dynobj, info))
- return FALSE;
+ return false;
- sgot = bfd_get_linker_section (dynobj, ".got");
+ sgot = elf_hash_table (info)->sgot;
+ srelgot = elf_hash_table (info)->srelgot;
}
if (local_got_refcounts == NULL)
amt *= sizeof (bfd_signed_vma);
local_got_refcounts = ((bfd_signed_vma *) bfd_zalloc (abfd, amt));
if (local_got_refcounts == NULL)
- return FALSE;
+ return false;
local_got_refcounts++;
elf_local_got_refcounts (abfd) = local_got_refcounts;
break;
}
- /* Some relocs require a global offset table (but perhaps not a
- specific GOT entry). */
- switch (r_type)
- {
- case R_CRIS_16_DTPREL:
- case R_CRIS_32_DTPREL:
- /* Not requesting .got.rela for an executable: the contents
- of the first entry is constant there. For a shared
- library, we need .got.rela for the R_CRIS_DTPMOD
- relocation at index 3. */
- if (!info->shared)
- break;
- /* Fall through. */
-
- case R_CRIS_32_IE:
- case R_CRIS_32_GD:
- case R_CRIS_16_GOT_GD:
- case R_CRIS_32_GOT_GD:
- case R_CRIS_32_GOT_TPREL:
- case R_CRIS_16_GOT_TPREL:
- /* Fall through. */
-
- /* For R_CRIS_16_GOTPLT and R_CRIS_32_GOTPLT, we need a GOT
- entry only for local symbols. Unfortunately, we don't know
- until later on if there's a version script that forces the
- symbol local. We must have the .rela.got section in place
- before we know if the symbol looks global now, so we need
- to treat the reloc just like for R_CRIS_16_GOT and
- R_CRIS_32_GOT. */
- case R_CRIS_16_GOTPLT:
- case R_CRIS_32_GOTPLT:
- case R_CRIS_16_GOT:
- case R_CRIS_32_GOT:
- if (srelgot == NULL
- && (h != NULL || info->shared))
- {
- srelgot = bfd_get_linker_section (dynobj, ".rela.got");
- if (srelgot == NULL)
- {
- flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
- | SEC_IN_MEMORY | SEC_LINKER_CREATED
- | SEC_READONLY);
- srelgot = bfd_make_section_anyway_with_flags (dynobj,
- ".rela.got",
- flags);
- if (srelgot == NULL
- || !bfd_set_section_alignment (dynobj, srelgot, 2))
- return FALSE;
- }
- }
- break;
-
- default:
- break;
- }
-
/* Warn and error for invalid input. */
switch (r_type)
{
case R_CRIS_32_TPREL:
case R_CRIS_16_TPREL:
case R_CRIS_32_GD:
- if (info->shared)
+ if (bfd_link_pic (info))
{
- (*_bfd_error_handler)
- (_("%B, section %A:\n relocation %s not valid"
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB, section %pA:\n relocation %s not valid"
" in a shared object;"
" typically an option mixup, recompile with -fPIC"),
abfd,
/* Those relocs also require that a DSO is of type
Initial Exec. Like other targets, we don't reset this
flag even if the relocs are GC:ed away. */
- if (info->shared)
+ if (bfd_link_pic (info))
info->flags |= DF_STATIC_TLS;
break;
}
switch (r_type)
- {
+ {
case R_CRIS_16_GOTPLT:
case R_CRIS_32_GOTPLT:
/* Mark that we need a GOT entry if the PLT entry (and its GOT
if (h->dynindx == -1)
{
if (!bfd_elf_link_record_dynamic_symbol (info, h))
- return FALSE;
+ return false;
}
}
if (local_got_refcounts[r_symndx_lgot] == 0)
{
sgot->size += got_element_size;
- if (info->shared)
+ if (bfd_link_pic (info))
{
/* If we are generating a shared object, we need
to output a R_CRIS_RELATIVE reloc so that the
case R_CRIS_32_PLT_PCREL:
/* This symbol requires a procedure linkage table entry. We
actually build the entry in adjust_dynamic_symbol,
- because this might be a case of linking PIC code which is
- never referenced by a dynamic object, in which case we
- don't need to generate a procedure linkage table entry
- after all. */
+ because this might be a case of linking PIC code which is
+ never referenced by a dynamic object, in which case we
+ don't need to generate a procedure linkage table entry
+ after all. */
/* Beware: if we'd check for visibility of the symbol here
(and not marking the need for a PLT when non-visible), we'd
continue;
h->needs_plt = 1;
- h->plt.refcount++;
+
+ /* If the symbol is forced local, the refcount is unavailable. */
+ if (h->plt.refcount != -1)
+ h->plt.refcount++;
break;
case R_CRIS_8:
can't help tables of (global) function pointers, for
example, though they must be emitted in a (writable) data
section to avoid having impure text sections. */
- if (info->shared
+ if (bfd_link_pic (info)
&& (sec->flags & SEC_ALLOC) != 0
&& (sec->flags & SEC_READONLY) != 0)
{
/* FIXME: How do we make this optionally a warning only? */
- (*_bfd_error_handler)
- (_("%B, section %A:\n relocation %s should not"
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB, section %pA: relocation %s should not"
" be used in a shared object; recompile with -fPIC"),
abfd,
sec,
render the symbol local. */
/* No need to do anything if we're not creating a shared object. */
- if (! info->shared)
+ if (! bfd_link_pic (info)
+ || (h != NULL && UNDEFWEAK_NO_DYNAMIC_RELOC (info, h)))
break;
/* We may need to create a reloc section in the dynobj and made room
if (sreloc == NULL)
{
sreloc = _bfd_elf_make_dynamic_reloc_section
- (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
+ (sec, dynobj, 2, abfd, /*rela?*/ true);
if (sreloc == NULL)
- return FALSE;
+ return false;
}
if (sec->flags & SEC_READONLY)
render the symbol local. */
/* No need to do anything if we're not creating a shared object. */
- if (! info->shared)
+ if (! bfd_link_pic (info))
break;
/* We don't need to handle relocs into sections not going into
this shared library) then we can also eliminate the
reloc. See comment above for more eliminable cases which
we can't identify at this time. */
- if (info->symbolic
+ if (SYMBOLIC_BIND (info, h)
&& h->root.type != bfd_link_hash_defweak
&& h->def_regular)
break;
if (sreloc == NULL)
{
sreloc = _bfd_elf_make_dynamic_reloc_section
- (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
+ (sec, dynobj, 2, abfd, /*rela?*/ true);
if (sreloc == NULL)
- return FALSE;
+ return false;
}
sreloc->size += sizeof (Elf32_External_Rela);
p = ((struct elf_cris_pcrel_relocs_copied *)
bfd_alloc (dynobj, (bfd_size_type) sizeof *p));
if (p == NULL)
- return FALSE;
+ return false;
p->next = eh->pcrel_relocs_copied;
eh->pcrel_relocs_copied = p;
p->section = sec;
}
break;
- /* This relocation describes the C++ object vtable hierarchy.
- Reconstruct it for later use during GC. */
- case R_CRIS_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_CRIS_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_CRIS_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_CRIS_GNU_VTENTRY:
+ if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
+ return false;
+ break;
case R_CRIS_16_TPREL:
case R_CRIS_32_TPREL:
default:
/* Other relocs do not appear here. */
bfd_set_error (bfd_error_bad_value);
- return FALSE;
- }
+ return false;
+ }
}
- return TRUE;
+ return true;
}
/* Set the sizes of the dynamic sections. */
-static bfd_boolean
+static bool
elf_cris_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
struct bfd_link_info *info)
{
struct elf_cris_link_hash_table * htab;
bfd *dynobj;
asection *s;
- bfd_boolean plt;
- bfd_boolean relocs;
+ bool relocs;
htab = elf_cris_hash_table (info);
if (htab == NULL)
- return FALSE;
+ return false;
- dynobj = elf_hash_table (info)->dynobj;
+ dynobj = htab->root.dynobj;
BFD_ASSERT (dynobj != NULL);
- if (elf_hash_table (info)->dynamic_sections_created)
+ if (htab->root.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);
not actually use these entries. Reset the size of .rela.got,
which will cause it to get stripped from the output file
below. */
- s = bfd_get_linker_section (dynobj, ".rela.got");
+ s = htab->root.srelgot;
if (s != NULL)
s->size = 0;
}
for relocs that have become for local symbols due to symbol
visibility changes. For programs, we discard space for relocs for
symbols not referenced by any dynamic object. */
- if (info->shared)
+ if (bfd_link_pic (info))
elf_cris_link_hash_traverse (htab,
elf_cris_discard_excess_dso_dynamics,
info);
/* The check_relocs and adjust_dynamic_symbol entry points have
determined the sizes of the various dynamic sections. Allocate
memory for them. */
- plt = FALSE;
- relocs = FALSE;
+ relocs = false;
for (s = dynobj->sections; s != NULL; s = s->next)
{
const char *name;
/* 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, s);
+ name = bfd_section_name (s);
if (strcmp (name, ".plt") == 0)
{
- /* Remember whether there is a PLT. */
- plt = s->size != 0;
+ ;
}
else if (strcmp (name, ".got.plt") == 0)
{
s->size += htab->dtpmod_refcount != 0
? 8 : 0;
}
- else if (CONST_STRNEQ (name, ".rela"))
+ else if (startswith (name, ".rela"))
{
if (strcmp (name, ".rela.got") == 0
&& htab->dtpmod_refcount != 0
- && info->shared)
+ && bfd_link_pic (info))
s->size += sizeof (Elf32_External_Rela);
if (s->size != 0)
{
/* Remember whether there are any reloc sections other
- than .rela.plt. */
+ than .rela.plt. */
if (strcmp (name, ".rela.plt") != 0)
- relocs = TRUE;
+ relocs = true;
/* We use the reloc_count field as a counter if we need
to copy relocs into the output file. */
s->reloc_count = 0;
}
}
- else if (! CONST_STRNEQ (name, ".got")
- && strcmp (name, ".dynbss") != 0)
+ else if (! startswith (name, ".got")
+ && strcmp (name, ".dynbss") != 0
+ && s != htab->root.sdynrelro)
{
/* It's not one of our sections, so don't allocate space. */
continue;
this will make entries have the type R_CRIS_NONE. */
s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
if (s->contents == NULL)
- return FALSE;
+ return false;
}
- if (elf_hash_table (info)->dynamic_sections_created)
- {
- /* Add some entries to the .dynamic section. We fill in the
- values later, in elf_cris_finish_dynamic_sections, but we
- must add the entries now so that we get the correct size for
- the .dynamic section. 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 (!info->shared)
- {
- if (!add_dynamic_entry (DT_DEBUG, 0))
- return FALSE;
- }
-
- if (plt)
- {
- if (!add_dynamic_entry (DT_PLTGOT, 0)
- || !add_dynamic_entry (DT_PLTRELSZ, 0)
- || !add_dynamic_entry (DT_PLTREL, DT_RELA)
- || !add_dynamic_entry (DT_JMPREL, 0))
- return FALSE;
- }
-
- if (relocs)
- {
- if (!add_dynamic_entry (DT_RELA, 0)
- || !add_dynamic_entry (DT_RELASZ, 0)
- || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
- return FALSE;
- }
-
- if ((info->flags & DF_TEXTREL) != 0)
- {
- if (!add_dynamic_entry (DT_TEXTREL, 0))
- return FALSE;
- info->flags |= DF_TEXTREL;
- }
- }
-#undef add_dynamic_entry
-
- return TRUE;
+ return _bfd_elf_add_dynamic_tags (output_bfd, info, relocs);
}
/* This function is called via elf_cris_link_hash_traverse if we are
check_relocs routine, but we won't fill them in in the
relocate_section routine. */
-static bfd_boolean
+static bool
elf_cris_discard_excess_dso_dynamics (struct elf_cris_link_hash_entry *h,
void * inf)
{
any relocs. */
if (h->root.def_regular
&& (h->root.forced_local
- || info->symbolic))
+ || SYMBOLIC_BIND (info, &h->root)))
{
for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
{
= _bfd_elf_get_dynamic_reloc_section (elf_hash_table (info)
->dynobj,
s->section,
- /*rela?*/ TRUE);
+ /*rela?*/ true);
sreloc->size -= s->count * sizeof (Elf32_External_Rela);
}
- return TRUE;
+ return true;
}
/* If we have accounted for PC-relative relocs for read-only
if ((s->section->flags & SEC_READONLY) != 0)
{
/* FIXME: How do we make this optionally a warning only? */
- (*_bfd_error_handler)
- (_("%B, section `%A', to symbol `%s':\n"
- " relocation %s should not be used"
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB, section `%pA', to symbol `%s':"
+ " relocation %s should not be used"
" in a shared object; recompile with -fPIC"),
s->section->owner,
s->section,
info->flags |= DF_TEXTREL;
}
- return TRUE;
+ return true;
}
/* This function is called via elf_cris_link_hash_traverse if we are *not*
creating a shared object. We discard space for relocs for symbols put
in the .got, but which we found we do not have to resolve at run-time. */
-static bfd_boolean
+static bool
elf_cris_discard_excess_program_dynamics (struct elf_cris_link_hash_entry *h,
void * inf)
{
&& elf_hash_table (info)->dynamic_sections_created)
{
bfd *dynobj = elf_hash_table (info)->dynobj;
- asection *srelgot;
+ asection *srelgot = elf_hash_table (info)->srelgot;
BFD_ASSERT (dynobj != NULL);
-
- srelgot = bfd_get_linker_section (dynobj, ".rela.got");
-
BFD_ASSERT (srelgot != NULL);
srelgot->size -= sizeof (Elf32_External_Rela);
have to export it as a dynamic symbol. This was already done for
functions; doing this for all symbols would presumably not
introduce new problems. Of course we don't do this if we're
- exporting all dynamic symbols. */
- if (! info->export_dynamic
+ exporting all dynamic symbols, or all data symbols, regardless of
+ them being referenced or not. */
+ if (! (info->export_dynamic
+ || (h->root.type != STT_FUNC && info->dynamic_data))
&& h->root.dynindx != -1
+ && !h->root.dynamic
&& !h->root.def_dynamic
&& !h->root.ref_dynamic)
{
}
}
- return TRUE;
+ return true;
}
/* Reject a file depending on presence and expectation of prefixed
underscores on symbols. */
-static bfd_boolean
+static bool
cris_elf_object_p (bfd *abfd)
{
if (! cris_elf_set_mach_from_flags (abfd, elf_elfheader (abfd)->e_flags))
- return FALSE;
+ return false;
if ((elf_elfheader (abfd)->e_flags & EF_CRIS_UNDERSCORE))
return (bfd_get_symbol_leading_char (abfd) == '_');
/* Mark presence or absence of leading underscore. Set machine type
flags from mach type. */
-static void
-cris_elf_final_write_processing (bfd *abfd,
- bfd_boolean linker ATTRIBUTE_UNUSED)
+static bool
+cris_elf_final_write_processing (bfd *abfd)
{
unsigned long e_flags = elf_elfheader (abfd)->e_flags;
default:
_bfd_abort (__FILE__, __LINE__,
- _("Unexpected machine number"));
+ _("unexpected machine number"));
}
elf_elfheader (abfd)->e_flags = e_flags;
+ return _bfd_elf_final_write_processing (abfd);
}
/* Set the mach type from e_flags value. */
-static bfd_boolean
+static bool
cris_elf_set_mach_from_flags (bfd *abfd,
unsigned long flags)
{
with this code; we'd have to require that all future handling
would be optional. */
bfd_set_error (bfd_error_wrong_format);
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
/* Display the flags field. */
-static bfd_boolean
+static bool
cris_elf_print_private_bfd_data (bfd *abfd, void * ptr)
{
FILE *file = (FILE *) ptr;
fprintf (file, _(" [v32]"));
fputc ('\n', file);
- return TRUE;
+ return true;
}
/* Don't mix files with and without a leading underscore. */
-static bfd_boolean
-cris_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
+static bool
+cris_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
{
+ bfd *obfd = info->output_bfd;
int imach, omach;
- if (! _bfd_generic_verify_endian_match (ibfd, obfd))
- return FALSE;
+ if (! _bfd_generic_verify_endian_match (ibfd, info))
+ return false;
if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
|| bfd_get_flavour (obfd) != bfd_target_elf_flavour)
- return TRUE;
+ return true;
imach = bfd_get_mach (ibfd);
if (! elf_flags_init (obfd))
{
/* This happens when ld starts out with a 'blank' output file. */
- elf_flags_init (obfd) = TRUE;
+ elf_flags_init (obfd) = true;
/* We ignore the linker-set mach, and instead set it according to
the first input file. This would also happen if we could
the output type, which might be a sane thing to do for a
v10+v32 compatibility object. */
if (! bfd_set_arch_mach (obfd, bfd_arch_cris, imach))
- return FALSE;
+ return false;
}
if (bfd_get_symbol_leading_char (ibfd)
!= bfd_get_symbol_leading_char (obfd))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(bfd_get_symbol_leading_char (ibfd) == '_'
- ? _("%B: uses _-prefixed symbols, but writing file with non-prefixed symbols")
- : _("%B: uses non-prefixed symbols, but writing file with _-prefixed symbols"),
+ ? _("%pB: uses _-prefixed symbols, but writing file with non-prefixed symbols")
+ : _("%pB: uses non-prefixed symbols, but writing file with _-prefixed symbols"),
ibfd);
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
omach = bfd_get_mach (obfd);
|| (omach == bfd_mach_cris_v32
&& imach != bfd_mach_cris_v10_v32))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
((imach == bfd_mach_cris_v32)
- ? _("%B contains CRIS v32 code, incompatible"
+ ? _("%pB contains CRIS v32 code, incompatible"
" with previous objects")
- : _("%B contains non-CRIS-v32 code, incompatible"
+ : _("%pB contains non-CRIS-v32 code, incompatible"
" with previous objects"),
ibfd);
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
/* We don't have to check the case where the input is compatible
to the other (compatible) mach. */
if (omach == bfd_mach_cris_v10_v32
&& ! bfd_set_arch_mach (obfd, bfd_arch_cris, imach))
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
/* Do side-effects of e_flags copying to obfd. */
-static bfd_boolean
+static bool
cris_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
{
- /* Call the base function. */
- if (!_bfd_elf_copy_private_bfd_data (ibfd, obfd))
- return FALSE;
-
- /* If output is big-endian for some obscure reason, stop here. */
- if (_bfd_generic_verify_endian_match (ibfd, obfd) == FALSE)
- return FALSE;
-
if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
|| bfd_get_flavour (obfd) != bfd_target_elf_flavour)
- return TRUE;
+ return true;
+
+ /* Call the base function. */
+ if (!_bfd_elf_copy_private_bfd_data (ibfd, obfd))
+ return false;
/* Do what we really came here for. */
return bfd_set_arch_mach (obfd, bfd_arch_cris, bfd_get_mach (ibfd));
#define elf_info_to_howto cris_info_to_howto_rela
#define elf_backend_relocate_section cris_elf_relocate_section
#define elf_backend_gc_mark_hook cris_elf_gc_mark_hook
-#define elf_backend_gc_sweep_hook cris_elf_gc_sweep_hook
#define elf_backend_plt_sym_val cris_elf_plt_sym_val
-#define elf_backend_check_relocs cris_elf_check_relocs
+#define elf_backend_check_relocs cris_elf_check_relocs
#define elf_backend_grok_prstatus cris_elf_grok_prstatus
#define elf_backend_grok_psinfo cris_elf_grok_psinfo
#define elf_backend_want_plt_sym 0
#define elf_backend_got_header_size 12
#define elf_backend_got_elt_size elf_cris_got_elt_size
+#define elf_backend_dtrel_excludes_plt 1
+#define elf_backend_want_dynrelro 1
/* Later, we my want to optimize RELA entries into REL entries for dynamic
linking and libraries (if it's a win of any significance). Until then,
#define elf_backend_may_use_rela_p 1
#define elf_backend_rela_normal 1
+#define elf_backend_linux_prpsinfo32_ugid16 true
+
#include "elf32-target.h"
#undef TARGET_LITTLE_SYM
projects / deliverable / binutils-gdb.git / blobdiff