/* CRIS-specific support for 32-bit ELF.
- Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
- 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.
#include "elf/cris.h"
#include <limits.h>
-/* Forward declarations. */
-static reloc_howto_type * cris_reloc_type_lookup
- PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
-
-static void cris_info_to_howto_rela
- PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
-
-static bfd_reloc_status_type cris_elf_pcrel_reloc
- PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
-
-static bfd_boolean cris_elf_grok_prstatus
- PARAMS ((bfd *abfd, Elf_Internal_Note *note));
-
-static bfd_boolean cris_elf_grok_psinfo
- PARAMS ((bfd *abfd, Elf_Internal_Note *note));
-
-static bfd_boolean cris_elf_relocate_section
- PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
- Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
-
-static bfd_reloc_status_type cris_final_link_relocate
- PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_byte *,
- Elf_Internal_Rela *, bfd_vma));
-
-static bfd_boolean cris_elf_object_p PARAMS ((bfd *));
-
-static void cris_elf_final_write_processing PARAMS ((bfd *, bfd_boolean));
-
-static bfd_boolean cris_elf_set_mach_from_flags
- PARAMS ((bfd *, unsigned long int));
-
-static bfd_boolean cris_elf_print_private_bfd_data PARAMS ((bfd *, PTR));
-
-static bfd_boolean cris_elf_merge_private_bfd_data PARAMS ((bfd *, bfd *));
-static bfd_boolean cris_elf_copy_private_bfd_data PARAMS ((bfd *, bfd *));
-
-struct elf_cris_link_hash_entry;
-static bfd_boolean elf_cris_discard_excess_dso_dynamics
- PARAMS ((struct elf_cris_link_hash_entry *, PTR));
-static bfd_boolean elf_cris_discard_excess_program_dynamics
- PARAMS ((struct elf_cris_link_hash_entry *, PTR));
-static bfd_boolean elf_cris_adjust_gotplt_to_got
- PARAMS ((struct elf_cris_link_hash_entry *, PTR));
-static bfd_boolean elf_cris_try_fold_plt_to_got
- PARAMS ((struct elf_cris_link_hash_entry *, PTR));
-static struct bfd_hash_entry *elf_cris_link_hash_newfunc
- PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
-static struct bfd_link_hash_table *elf_cris_link_hash_table_create
- PARAMS ((bfd *));
-static bfd_boolean elf_cris_adjust_dynamic_symbol
- PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
-static bfd_boolean cris_elf_check_relocs
- PARAMS ((bfd *, struct bfd_link_info *, asection *,
- const Elf_Internal_Rela *));
-
-static bfd_boolean elf_cris_size_dynamic_sections
- PARAMS ((bfd *, struct bfd_link_info *));
-static bfd_boolean elf_cris_finish_dynamic_symbol
- PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
- Elf_Internal_Sym *));
-static bfd_boolean elf_cris_finish_dynamic_sections
- PARAMS ((bfd *, struct bfd_link_info *));
-static void elf_cris_hide_symbol
- PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *, bfd_boolean));
-static enum elf_reloc_type_class elf_cris_reloc_type_class
- PARAMS ((const Elf_Internal_Rela *));
+bfd_reloc_status_type
+cris_elf_pcrel_reloc (bfd *, arelent *, asymbol *, void *,
+ asection *, bfd *, char **);
+static bool
+cris_elf_set_mach_from_flags (bfd *, unsigned long);
+/* Forward declarations. */
static reloc_howto_type cris_elf_howto_table [] =
{
/* 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)
};
static reloc_howto_type *
-cris_reloc_type_lookup (abfd, code)
- bfd * abfd ATTRIBUTE_UNUSED;
- bfd_reloc_code_real_type code;
+cris_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
+ bfd_reloc_code_real_type code)
{
unsigned int i;
/* Set the howto pointer for an CRIS ELF reloc. */
-static void
-cris_info_to_howto_rela (abfd, cache_ptr, dst)
- bfd * abfd ATTRIBUTE_UNUSED;
- arelent * cache_ptr;
- Elf_Internal_Rela * dst;
+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
-cris_elf_pcrel_reloc (abfd, reloc_entry, symbol, data, input_section,
- output_bfd, error_message)
- bfd *abfd ATTRIBUTE_UNUSED;
- arelent *reloc_entry;
- asymbol *symbol;
- PTR data ATTRIBUTE_UNUSED;
- asection *input_section;
- bfd *output_bfd;
- char **error_message ATTRIBUTE_UNUSED;
+cris_elf_pcrel_reloc (bfd *abfd ATTRIBUTE_UNUSED,
+ arelent *reloc_entry,
+ asymbol *symbol,
+ void * data ATTRIBUTE_UNUSED,
+ asection *input_section,
+ bfd *output_bfd,
+ char **error_message ATTRIBUTE_UNUSED)
{
/* By default (using only bfd_elf_generic_reloc when linking to
non-ELF formats) PC-relative relocs are relative to the beginning
some similarities with other ports, hoping to simplify general
changes, while still keeping Linux/CRIS and Linux/CRISv32 code apart. */
-static bfd_boolean
-cris_elf_grok_prstatus (abfd, note)
- bfd *abfd;
- Elf_Internal_Note *note;
+static bool
+cris_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
{
int offset;
size_t size;
switch (note->descsz)
{
default:
- return FALSE;
+ return false;
case 202: /* Linux/CRISv32 */
/* pr_cursig */
- elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
+ elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
/* pr_pid */
- elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 22);
+ elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 22);
/* pr_reg */
offset = 70;
switch (note->descsz)
{
default:
- return FALSE;
+ return false;
case 214: /* Linux/CRIS */
/* pr_cursig */
- elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
+ elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
/* pr_pid */
- elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 22);
+ elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 22);
/* pr_reg */
offset = 70;
size, note->descpos + offset);
}
-static bfd_boolean
-cris_elf_grok_psinfo (abfd, note)
- bfd *abfd;
- Elf_Internal_Note *note;
+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
+ elf_tdata (abfd)->core->program
= _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
- elf_tdata (abfd)->core_command
+ elf_tdata (abfd)->core->command
= _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
}
else
switch (note->descsz)
{
default:
- return FALSE;
+ return false;
case 124: /* Linux/CRIS elf_prpsinfo */
- elf_tdata (abfd)->core_program
+ elf_tdata (abfd)->core->program
= _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
- elf_tdata (abfd)->core_command
+ elf_tdata (abfd)->core->command
= _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
}
implementations, so strip it off if it exists. */
{
- char *command = elf_tdata (abfd)->core_command;
+ char *command = elf_tdata (abfd)->core->command;
int n = strlen (command);
if (0 < n && command[n - 1] == ' ')
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 bool
+elf_cris_discard_excess_dso_dynamics (struct elf_cris_link_hash_entry *,
+ void * );
+static bool
+elf_cris_discard_excess_program_dynamics (struct elf_cris_link_hash_entry *,
+ void *);
+
/* The local_got_refcounts and local_got_offsets are a multiple of
LSNUM in size, namely LGOT_ALLOC_NELTS_FOR(LSNUM) (plus one for the
refcount for GOT itself, see code), with the summary / group offset
#define elf_cris_link_hash_traverse(table, func, info) \
(elf_link_hash_traverse \
(&(table)->root, \
- (bfd_boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (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) \
- ((struct elf_cris_link_hash_table *) (p)->hash)
+ ((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
/* Create an entry in a CRIS ELF linker hash table. */
static struct bfd_hash_entry *
-elf_cris_link_hash_newfunc (entry, table, string)
- struct bfd_hash_entry *entry;
- struct bfd_hash_table *table;
- const char *string;
+elf_cris_link_hash_newfunc (struct bfd_hash_entry *entry,
+ struct bfd_hash_table *table,
+ const char *string)
{
struct elf_cris_link_hash_entry *ret =
(struct elf_cris_link_hash_entry *) entry;
/* Create a CRIS ELF linker hash table. */
static struct bfd_link_hash_table *
-elf_cris_link_hash_table_create (abfd)
- bfd *abfd;
+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_malloc (amt));
+ ret = ((struct elf_cris_link_hash_table *) bfd_zmalloc (amt));
if (ret == (struct elf_cris_link_hash_table *) NULL)
return NULL;
if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
elf_cris_link_hash_newfunc,
- sizeof (struct elf_cris_link_hash_entry)))
+ sizeof (struct elf_cris_link_hash_entry),
+ CRIS_ELF_DATA))
{
free (ret);
return NULL;
are used for run-time symbol evaluation. */
ret->next_gotplt_entry = 12;
- /* We haven't seen any R_CRIS_nn_GOT_TPREL initially. */
- ret->dtpmod_refcount = 0;
-
return &ret->root.root;
}
\f
routines, with a few tweaks. */
static bfd_reloc_status_type
-cris_final_link_relocate (howto, input_bfd, input_section, contents, rel,
- relocation)
- reloc_howto_type * howto;
- bfd * input_bfd;
- asection * input_section;
- bfd_byte * contents;
- Elf_Internal_Rela * rel;
- bfd_vma relocation;
+cris_final_link_relocate (reloc_howto_type * howto,
+ bfd * input_bfd,
+ asection * input_section,
+ bfd_byte * contents,
+ Elf_Internal_Rela * rel,
+ 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
-cris_elf_relocate_section (output_bfd, info, input_bfd, input_section,
- contents, relocs, local_syms, local_sections)
- bfd *output_bfd ATTRIBUTE_UNUSED;
- struct bfd_link_info *info;
- bfd *input_bfd;
- asection *input_section;
- bfd_byte *contents;
- Elf_Internal_Rela *relocs;
- Elf_Internal_Sym *local_syms;
- asection **local_sections;
+static int
+cris_elf_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
+ struct bfd_link_info *info,
+ bfd *input_bfd,
+ asection *input_section,
+ bfd_byte *contents,
+ Elf_Internal_Rela *relocs,
+ Elf_Internal_Sym *local_syms,
+ asection **local_sections)
{
+ struct elf_cris_link_hash_table * htab;
bfd *dynobj;
Elf_Internal_Shdr *symtab_hdr;
struct elf_link_hash_entry **sym_hashes;
Elf_Internal_Rela *relend;
asection *srelgot;
- dynobj = elf_hash_table (info)->dynobj;
+ htab = elf_cris_hash_table (info);
+ if (htab == NULL)
+ return false;
+
+ 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_section_by_name (dynobj, ".plt");
- sgot = bfd_get_section_by_name (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;
- 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,
h, sec, relocation,
- unresolved_reloc, warned);
+ unresolved_reloc, warned, ignored);
symname = h->root.root.string;
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;
}
}
}
- if (sec != NULL && elf_discarded_section (sec))
- {
- /* For relocs against symbols from removed linkonce sections,
- or sections discarded by a linker script, we just want the
- section contents zeroed. Avoid any special processing. */
- _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
- rel->r_info = 0;
- rel->r_addend = 0;
- continue;
- }
+ if (sec != NULL && discarded_section (sec))
+ 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_section_by_name (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_section_by_name (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
- && r_symndx != 0
+ 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
- (input_bfd, 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
{
indx = elf_section_data (osec)->dynindx;
if (indx == 0)
{
- struct elf_cris_link_hash_table *htab;
- htab = elf_cris_hash_table (info);
osec = htab->root.text_index_section;
indx = elf_section_data (osec)->dynindx;
}
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
- || elf_cris_hash_table (info)->dtpmod_refcount != 0);
+ || htab->dtpmod_refcount != 0);
/* Fill in a R_CRIS_DTPMOD reloc at offset 3 if we haven't
already done so. Note that we do this in .got.plt, not
in .got, as .got.plt contains the first part, still the
reloc is against .got, because the linker script directs
(is required to direct) them both into .got. */
- if (elf_cris_hash_table (info)->dtpmod_refcount > 0
+ if (htab->dtpmod_refcount > 0
&& (input_section->flags & SEC_ALLOC) != 0)
{
- asection *sgotplt = bfd_get_section_by_name (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_section_by_name (dynobj, ".rela.got");
+ srelgot = htab->root.srelgot;
BFD_ASSERT (srelgot != NULL);
loc = srelgot->contents;
loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
/* Reverse the sign to mark that we've emitted the
required GOT entry. */
- elf_cris_hash_table (info)->dtpmod_refcount
- = -elf_cris_hash_table (info)->dtpmod_refcount;
+ htab->dtpmod_refcount = - htab->dtpmod_refcount;
}
/* The relocation is the offset from the start of the module
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_section_by_name (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 && (h == NULL || h->def_regular))
+ if (!bfd_link_pic (info)
+ && (h == NULL || h->def_regular || ELF_COMMON_DEF_P (h)))
{
/* Known contents of the GOT. */
bfd_vma off;
else
local_got_offsets[r_symndx] |= 1;
- if (srelgot == NULL)
- srelgot = bfd_get_section_by_name (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
-elf_cris_finish_dynamic_symbol (output_bfd, info, h, sym)
- bfd *output_bfd;
- struct bfd_link_info *info;
- struct elf_link_hash_entry *h;
- Elf_Internal_Sym *sym;
+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)
{
- bfd *dynobj;
+ struct elf_cris_link_hash_table * htab;
/* Where in the plt entry to put values. */
int plt_off1 = 2, plt_off2 = 10, plt_off3 = 16;
const bfd_byte *plt_entry = elf_cris_plt_entry;
const bfd_byte *plt_pic_entry = elf_cris_pic_plt_entry;
+ htab = elf_cris_hash_table (info);
+ if (htab == NULL)
+ 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;
asection *sgotplt;
- asection *sgot;
asection *srela;
bfd_vma got_base;
= 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.
processed as part of the runtime lazy .rela.plt relocation).
FIXME: There be literal constants here... */
bfd_vma rela_plt_index
- = (elf_cris_hash_table (info)->dtpmod_refcount != 0
+ = (htab->dtpmod_refcount != 0
? gotplt_offset/4 - 2 - 3 : gotplt_offset/4 - 3);
/* Get the offset into the .got table of the entry that corresponds
bfd_vma got_offset
= (has_gotplt
? gotplt_offset
- : h->got.offset + elf_cris_hash_table(info)->next_gotplt_entry);
+ : h->got.offset + htab->next_gotplt_entry);
/* This symbol has an entry in the procedure linkage table. Set it
up. */
BFD_ASSERT (h->dynindx != -1);
- splt = bfd_get_section_by_name (dynobj, ".plt");
- sgot = bfd_get_section_by_name (dynobj, ".got");
- sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
- srela = bfd_get_section_by_name (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_section_by_name (dynobj, ".got");
- srela = bfd_get_section_by_name (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_section_by_name (h->root.u.def.section->owner,
- ".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
}
/* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
- if (strcmp (h->root.root.string, "_DYNAMIC") == 0
+ if (h == elf_hash_table (info)->hdynamic
|| 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
-elf_cris_finish_dynamic_sections (output_bfd, info)
- bfd *output_bfd;
- struct bfd_link_info *info;
+static bool
+elf_cris_finish_dynamic_sections (bfd *output_bfd,
+ struct bfd_link_info *info)
{
bfd *dynobj;
asection *sgot;
dynobj = elf_hash_table (info)->dynobj;
- sgot = bfd_get_section_by_name (dynobj, ".got.plt");
+ sgot = elf_hash_table (info)->sgotplt;
BFD_ASSERT (sgot != NULL);
- sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
+ sdyn = bfd_get_linker_section (dynobj, ".dynamic");
if (elf_hash_table (info)->dynamic_sections_created)
{
asection *splt;
Elf32_External_Dyn *dyncon, *dynconend;
- splt = bfd_get_section_by_name (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. */
+/* The elf_backend_plt_sym_val hook function. */
-static bfd_boolean
-cris_elf_gc_sweep_hook (bfd *abfd,
- struct bfd_link_info *info,
- asection *sec,
- const Elf_Internal_Rela *relocs)
+static bfd_vma
+cris_elf_plt_sym_val (bfd_vma i ATTRIBUTE_UNUSED, const asection *plt,
+ const arelent *rel)
{
- 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;
+ bfd_size_type plt_entry_size;
+ bfd_size_type pltoffs;
+ bfd *abfd = plt->owner;
- dynobj = elf_hash_table (info)->dynobj;
- if (dynobj == NULL)
- return TRUE;
+ /* Same for CRIS and CRIS v32; see elf_cris_(|pic_)plt_entry(|_v32)[]. */
+ bfd_size_type plt_entry_got_offset = 2;
+ bfd_size_type plt_sec_size;
+ bfd_size_type got_vma_for_dyn;
+ asection *got;
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
- sym_hashes = elf_sym_hashes (abfd);
- local_got_refcounts = elf_local_got_refcounts (abfd);
+ /* FIXME: the .got section should be readily available also when
+ we're not linking. */
+ if ((got = bfd_get_section_by_name (abfd, ".got")) == NULL)
+ return (bfd_vma) -1;
- sgot = bfd_get_section_by_name (dynobj, ".got");
- srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
+ 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);
- relend = relocs + sec->reloc_count;
- for (rel = relocs; rel < relend; rel++)
+ /* Data in PLT is GOT-relative for DYN, but absolute for EXE. */
+ got_vma_for_dyn = (abfd->flags & EXEC_P) ? 0 : got->vma;
+
+ /* Because we can have merged GOT entries; a single .got entry for
+ both GOT and the PLT part of the GOT (.got.plt), the index of the
+ reloc in .rela.plt is not the same as the index in the PLT.
+ Instead, we have to hunt down the GOT offset in the PLT that
+ corresponds to that of this reloc. Unfortunately, we will only
+ be called for the .rela.plt relocs, so we'll miss synthetic
+ symbols for .plt entries with merged GOT entries. (FIXME:
+ fixable by providing our own bfd_elf32_get_synthetic_symtab.
+ Doesn't seem worthwile at time of this writing.) FIXME: we've
+ gone from O(1) to O(N) (N number of PLT entries) for finding each
+ PLT address. Shouldn't matter in practice though. */
+
+ for (pltoffs = plt_entry_size;
+ pltoffs < plt_sec_size;
+ pltoffs += plt_entry_size)
{
- 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;
+ bfd_size_type got_offset;
+ bfd_byte gotoffs_raw[4];
- 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;
- }
+ if (!bfd_get_section_contents (abfd, (asection *) plt, gotoffs_raw,
+ pltoffs + plt_entry_got_offset,
+ sizeof (gotoffs_raw)))
+ return (bfd_vma) -1;
- 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;
- /* 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_PCREL:
- case R_CRIS_16_PCREL:
- case R_CRIS_32_PCREL:
- case R_CRIS_32_PLT_PCREL:
- 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:
- elf_cris_hash_table (info)->dtpmod_refcount--;
- if (elf_cris_hash_table (info)->dtpmod_refcount == 0)
- elf_cris_hash_table (info)->next_gotplt_entry -= 8;
- BFD_ASSERT (local_got_refcounts != NULL);
- local_got_refcounts[-1]--;
- break;
-
- default:
- break;
- }
+ got_offset = bfd_get_32 (abfd, gotoffs_raw);
+ if (got_offset + got_vma_for_dyn == rel->address)
+ return plt->vma + pltoffs;
}
- return TRUE;
-}
-
-/* The elf_backend_plt_sym_val hook function. */
-
-static bfd_vma
-cris_elf_plt_sym_val (bfd_vma i, const asection *plt,
- const arelent *rel ATTRIBUTE_UNUSED)
-{
- bfd_size_type plt_entry_size;
-
- plt_entry_size
- = (bfd_get_mach (plt->owner) == bfd_mach_cris_v32
- ? PLT_ENTRY_SIZE_V32 : PLT_ENTRY_SIZE);
-
- return plt->vma + (i + 1) * plt_entry_size;
+ /* While it's tempting to BFD_ASSERT that we shouldn't get here,
+ that'd not be graceful behavior for invalid input. */
+ return (bfd_vma) -1;
}
/* Make sure we emit a GOT entry if the symbol was supposed to have a PLT
or elf_cris_size_dynamic_sections if no dynamic sections will be
created (we're only linking static objects). */
-static bfd_boolean
-elf_cris_adjust_gotplt_to_got (h, p)
- struct elf_cris_link_hash_entry *h;
- PTR p;
+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;
- if (h->root.root.type == bfd_link_hash_warning)
- h = (struct elf_cris_link_hash_entry *) h->root.root.u.i.link;
+ /* A GOTPLT reloc, when activated, is supposed to be included into
+ 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_section_by_name (dynobj, ".got");
- srelgot = bfd_get_section_by_name (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
-elf_cris_try_fold_plt_to_got (h, p)
- struct elf_cris_link_hash_entry *h;
- PTR p;
+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
entry. */
static void
-elf_cris_hide_symbol (info, h, force_local)
- struct bfd_link_info *info;
- struct elf_link_hash_entry *h;
- bfd_boolean force_local;
+elf_cris_hide_symbol (struct bfd_link_info *info,
+ struct elf_link_hash_entry *h,
+ 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
-elf_cris_adjust_dynamic_symbol (info, h)
- struct bfd_link_info *info;
- struct elf_link_hash_entry *h;
+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;
- dynobj = elf_hash_table (info)->dynobj;
+ htab = elf_cris_hash_table (info);
+ if (htab == NULL)
+ return false;
+
+ 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_section_by_name (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. */
/* We also need to make an entry in the .got.plt section, which
will be placed in the .got section by the linker script. */
((struct elf_cris_link_hash_entry *) h)->gotplt_offset
- = elf_cris_hash_table (info)->next_gotplt_entry;
- elf_cris_hash_table (info)->next_gotplt_entry += 4;
+ = htab->next_gotplt_entry;
+ htab->next_gotplt_entry += 4;
- s = bfd_get_section_by_name (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_section_by_name (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;
-
- if (h->size == 0)
- {
- (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
- h->root.root.string);
- 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_section_by_name (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_ALLOC) != 0)
- {
- asection *srel;
- srel = bfd_get_section_by_name (dynobj, ".rela.bss");
+ 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)
+ {
BFD_ASSERT (srel != NULL);
srel->size += sizeof (Elf32_External_Rela);
h->needs_copy = 1;
}
- return _bfd_elf_adjust_dynamic_copy (h, s);
+ BFD_ASSERT (s != NULL);
+
+ return _bfd_elf_adjust_dynamic_copy (info, h, s);
}
/* Adjust our "subclass" elements for an indirect symbol. */
return;
}
- BFD_ASSERT (edir->pcrel_relocs_copied == NULL);
BFD_ASSERT (edir->gotplt_offset == 0 || eind->gotplt_offset == 0);
#define XMOVOPZ(F, OP, Z) edir->F OP eind->F; eind->F = Z
#define XMOVE(F) XMOVOPZ (F, +=, 0)
- XMOVOPZ (pcrel_relocs_copied, =, NULL);
+ if (eind->pcrel_relocs_copied != NULL)
+ {
+ if (edir->pcrel_relocs_copied != NULL)
+ {
+ struct elf_cris_pcrel_relocs_copied **pp;
+ struct elf_cris_pcrel_relocs_copied *p;
+
+ /* Add reloc counts against the indirect sym to the direct sym
+ list. Merge any entries against the same section. */
+ for (pp = &eind->pcrel_relocs_copied; *pp != NULL;)
+ {
+ struct elf_cris_pcrel_relocs_copied *q;
+ p = *pp;
+ for (q = edir->pcrel_relocs_copied; q != NULL; q = q->next)
+ if (q->section == p->section)
+ {
+ q->count += p->count;
+ *pp = p->next;
+ break;
+ }
+ if (q == NULL)
+ pp = &p->next;
+ }
+ *pp = edir->pcrel_relocs_copied;
+ }
+ XMOVOPZ (pcrel_relocs_copied, =, NULL);
+ }
XMOVE (gotplt_refcount);
XMOVE (gotplt_offset);
XMOVE (reg_got_refcount);
/* Look through the relocs for a section during the first phase. */
-static bfd_boolean
-cris_elf_check_relocs (abfd, info, sec, relocs)
- bfd *abfd;
- struct bfd_link_info *info;
- asection *sec;
- const Elf_Internal_Rela *relocs;
+static bool
+cris_elf_check_relocs (bfd *abfd,
+ struct bfd_link_info *info,
+ asection *sec,
+ const Elf_Internal_Rela *relocs)
{
+ struct elf_cris_link_hash_table * htab;
bfd *dynobj;
Elf_Internal_Shdr *symtab_hdr;
struct elf_link_hash_entry **sym_hashes;
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;
dynobj = elf_hash_table (info)->dynobj;
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
case R_CRIS_16_DTPREL:
/* The first .got.plt entry is right after the R_CRIS_DTPMOD
entry at index 3. */
- if (elf_cris_hash_table (info)->dtpmod_refcount == 0)
- elf_cris_hash_table (info)->next_gotplt_entry += 8;
- elf_cris_hash_table (info)->dtpmod_refcount++;
+ if (htab->dtpmod_refcount == 0)
+ htab->next_gotplt_entry += 8;
+
+ htab->dtpmod_refcount++;
/* Fall through. */
case R_CRIS_32_IE:
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;
}
-
- /* Create the .got section, so we can assume it's always
- present whenever there's a dynobj. */
- if (!_bfd_elf_create_got_section (dynobj, info))
- return FALSE;
}
if (sgot == NULL)
- sgot = bfd_get_section_by_name (dynobj, ".got");
+ {
+ /* We may have a dynobj but no .got section, if machine-
+ independent parts of the linker found a reason to create
+ a dynobj. We want to create the .got section now, so we
+ 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;
+
+ 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_section_by_name (dynobj, ".rela.got");
- if (srelgot == NULL)
- {
- srelgot = bfd_make_section_with_flags (dynobj,
- ".rela.got",
- (SEC_ALLOC
- | SEC_LOAD
- | SEC_HAS_CONTENTS
- | SEC_IN_MEMORY
- | SEC_LINKER_CREATED
- | SEC_READONLY));
- 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,
cris_elf_howto_table[r_type].name);
}
+
+ /* We don't need to handle relocs into sections not going into
+ the "real" output. */
+ if ((sec->flags & SEC_ALLOC) == 0)
+ break;
+
if (h != NULL)
{
h->non_got_ref = 1;
render the symbol local. */
/* No need to do anything if we're not creating a shared object. */
- if (! info->shared)
- break;
-
- /* We don't need to handle relocs into sections not going into
- the "real" output. */
- if ((sec->flags & SEC_ALLOC) == 0)
+ 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);
eh = elf_cris_hash_entry (h);
for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
- if (p->section == sreloc)
+ if (p->section == sec)
break;
if (p == NULL)
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 = sreloc;
+ p->section = sec;
p->count = 0;
p->r_type = r_type;
}
}
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
-elf_cris_size_dynamic_sections (output_bfd, info)
- bfd *output_bfd ATTRIBUTE_UNUSED;
- struct bfd_link_info *info;
+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;
- dynobj = elf_hash_table (info)->dynobj;
+ htab = elf_cris_hash_table (info);
+ if (htab == NULL)
+ return false;
+
+ 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_section_by_name (dynobj, ".interp");
+ s = bfd_get_linker_section (dynobj, ".interp");
BFD_ASSERT (s != NULL);
s->size = sizeof ELF_DYNAMIC_INTERPRETER;
s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
else
{
/* Adjust all expected GOTPLT uses to use a GOT entry instead. */
- elf_cris_link_hash_traverse (elf_cris_hash_table (info),
- elf_cris_adjust_gotplt_to_got,
- (PTR) info);
+ elf_cris_link_hash_traverse (htab, elf_cris_adjust_gotplt_to_got,
+ info);
/* We may have created entries in the .rela.got section.
However, if we are not creating the dynamic sections, we will
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_section_by_name (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)
- elf_cris_link_hash_traverse (elf_cris_hash_table (info),
+ if (bfd_link_pic (info))
+ elf_cris_link_hash_traverse (htab,
elf_cris_discard_excess_dso_dynamics,
- (PTR) info);
+ info);
else
- elf_cris_link_hash_traverse (elf_cris_hash_table (info),
+ elf_cris_link_hash_traverse (htab,
elf_cris_discard_excess_program_dynamics,
- (PTR) info);
+ 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)
{
/* The .got.plt contains the .got header as well as the
actual .got.plt contents. The .got header may contain a
R_CRIS_DTPMOD entry at index 3. */
- s->size += elf_cris_hash_table (info)->dtpmod_refcount != 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
- && elf_cris_hash_table (info)->dtpmod_refcount != 0
- && info->shared)
+ && htab->dtpmod_refcount != 0
+ && 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;
- }
-
- 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;
- }
+ return false;
}
-#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
-elf_cris_discard_excess_dso_dynamics (h, inf)
- struct elf_cris_link_hash_entry *h;
- PTR inf;
+static bool
+elf_cris_discard_excess_dso_dynamics (struct elf_cris_link_hash_entry *h,
+ void * inf)
{
struct elf_cris_pcrel_relocs_copied *s;
struct bfd_link_info *info = (struct bfd_link_info *) inf;
- if (h->root.root.type == bfd_link_hash_warning)
- h = (struct elf_cris_link_hash_entry *) h->root.root.u.i.link;
-
/* If a symbol has been forced local or we have found a regular
definition for the symbolic link case, then we won't be needing
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)
- s->section->size -= s->count * sizeof (Elf32_External_Rela);
-
- return TRUE;
+ {
+ asection *sreloc
+ = _bfd_elf_get_dynamic_reloc_section (elf_hash_table (info)
+ ->dynobj,
+ s->section,
+ /*rela?*/ true);
+ sreloc->size -= s->count * sizeof (Elf32_External_Rela);
+ }
+ return true;
}
/* If we have accounted for PC-relative relocs for read-only
late). */
for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
- {
- BFD_ASSERT ((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"
- " in a shared object; recompile with -fPIC"),
- s->section->owner,
- s->section,
- h->root.root.root.string,
- cris_elf_howto_table[s->r_type].name);
-
- info->flags |= DF_TEXTREL;
- }
+ if ((s->section->flags & SEC_READONLY) != 0)
+ {
+ /* FIXME: How do we make this optionally a warning only? */
+ _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,
+ h->root.root.root.string,
+ cris_elf_howto_table[s->r_type].name);
+
+ 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
-elf_cris_discard_excess_program_dynamics (h, inf)
- struct elf_cris_link_hash_entry *h;
- PTR inf;
+static bool
+elf_cris_discard_excess_program_dynamics (struct elf_cris_link_hash_entry *h,
+ void * inf)
{
struct bfd_link_info *info = (struct bfd_link_info *) inf;
- if (h->root.root.type == bfd_link_hash_warning)
- h = (struct elf_cris_link_hash_entry *) h->root.root.u.i.link;
-
/* If we're not creating a shared library and have a symbol which is
referred to by .got references, but the symbol is defined locally,
(or rather, not defined by a DSO) then lose the reloc for the .got
&& 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_section_by_name (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
-cris_elf_object_p (abfd)
- bfd *abfd;
+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 (abfd, linker)
- 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
-cris_elf_set_mach_from_flags (abfd, flags)
- bfd *abfd;
- unsigned long flags;
+static bool
+cris_elf_set_mach_from_flags (bfd *abfd,
+ unsigned long flags)
{
switch (flags & EF_CRIS_VARIANT_MASK)
{
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
-cris_elf_print_private_bfd_data (abfd, ptr)
- bfd *abfd;
- PTR ptr;
+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 (ibfd, obfd)
- 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
-cris_elf_copy_private_bfd_data (ibfd, obfd)
- bfd *ibfd;
- bfd *obfd;
+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));
}
static enum elf_reloc_type_class
-elf_cris_reloc_type_class (rela)
- const Elf_Internal_Rela *rela;
+elf_cris_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
+ const asection *rel_sec ATTRIBUTE_UNUSED,
+ const Elf_Internal_Rela *rela)
{
enum elf_cris_reloc_type r_type = ELF32_R_TYPE (rela->r_info);
switch (r_type)
}
\f
#define ELF_ARCH bfd_arch_cris
+#define ELF_TARGET_ID CRIS_ELF_DATA
#define ELF_MACHINE_CODE EM_CRIS
#define ELF_MAXPAGESIZE 0x2000
-#define TARGET_LITTLE_SYM bfd_elf32_cris_vec
+#define TARGET_LITTLE_SYM cris_elf32_vec
#define TARGET_LITTLE_NAME "elf32-cris"
#define elf_symbol_leading_char 0
#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
#undef TARGET_LITTLE_NAME
#undef elf_symbol_leading_char
-#define TARGET_LITTLE_SYM bfd_elf32_us_cris_vec
+#define TARGET_LITTLE_SYM cris_elf32_us_vec
#define TARGET_LITTLE_NAME "elf32-us-cris"
#define elf_symbol_leading_char '_'
#undef elf32_bed
projects / deliverable / binutils-gdb.git / blobdiff