/* Matsushita 10300 specific support for 32-bit ELF
- Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
- 2006, 2007, 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
+ Copyright (C) 1996-2021 Free Software Foundation, Inc.
This file is part of BFD, the Binary File Descriptor library.
struct
{
bfd_signed_vma refcount;
- bfd_vma offset;
- char got_allocated;
- char rel_emitted;
+ bfd_vma offset;
+ char got_allocated;
+ char rel_emitted;
} tls_ldm_got;
};
/* Get the MN10300 ELF linker hash table from a link_info structure. */
#define elf32_mn10300_hash_table(p) \
- (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
- == MN10300_ELF_DATA ? ((struct elf32_mn10300_link_hash_table *) ((p)->hash)) : NULL)
+ ((is_elf_hash_table ((p)->hash) \
+ && elf_hash_table_id (elf_hash_table (p)) == MN10300_ELF_DATA) \
+ ? (struct elf32_mn10300_link_hash_table *) (p)->hash : NULL)
#define elf32_mn10300_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)))
static reloc_howto_type elf_mn10300_howto_table[] =
/* Dummy relocation. Does nothing. */
HOWTO (R_MN10300_NONE,
0,
- 2,
- 16,
- FALSE,
+ 3,
0,
- complain_overflow_bitfield,
+ false,
+ 0,
+ complain_overflow_dont,
bfd_elf_generic_reloc,
"R_MN10300_NONE",
- FALSE,
+ false,
0,
0,
- FALSE),
+ false),
/* Standard 32 bit reloc. */
HOWTO (R_MN10300_32,
0,
2,
32,
- FALSE,
+ false,
0,
complain_overflow_bitfield,
bfd_elf_generic_reloc,
"R_MN10300_32",
- FALSE,
+ false,
0xffffffff,
0xffffffff,
- FALSE),
+ false),
/* Standard 16 bit reloc. */
HOWTO (R_MN10300_16,
0,
1,
16,
- FALSE,
+ false,
0,
complain_overflow_bitfield,
bfd_elf_generic_reloc,
"R_MN10300_16",
- FALSE,
+ false,
0xffff,
0xffff,
- FALSE),
+ false),
/* Standard 8 bit reloc. */
HOWTO (R_MN10300_8,
0,
0,
8,
- FALSE,
+ false,
0,
complain_overflow_bitfield,
bfd_elf_generic_reloc,
"R_MN10300_8",
- FALSE,
+ false,
0xff,
0xff,
- FALSE),
+ false),
/* Standard 32bit pc-relative reloc. */
HOWTO (R_MN10300_PCREL32,
0,
2,
32,
- TRUE,
+ true,
0,
complain_overflow_bitfield,
bfd_elf_generic_reloc,
"R_MN10300_PCREL32",
- FALSE,
+ false,
0xffffffff,
0xffffffff,
- TRUE),
+ true),
/* Standard 16bit pc-relative reloc. */
HOWTO (R_MN10300_PCREL16,
0,
1,
16,
- TRUE,
+ true,
0,
complain_overflow_bitfield,
bfd_elf_generic_reloc,
"R_MN10300_PCREL16",
- FALSE,
+ false,
0xffff,
0xffff,
- TRUE),
+ true),
/* Standard 8 pc-relative reloc. */
HOWTO (R_MN10300_PCREL8,
0,
0,
8,
- TRUE,
+ true,
0,
complain_overflow_bitfield,
bfd_elf_generic_reloc,
"R_MN10300_PCREL8",
- FALSE,
+ false,
0xff,
0xff,
- TRUE),
+ true),
/* GNU extension to record C++ vtable hierarchy. */
HOWTO (R_MN10300_GNU_VTINHERIT, /* type */
0, /* rightshift */
0, /* 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_MN10300_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_MN10300_GNU_VTENTRY, /* type */
0, /* rightshift */
0, /* 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_MN10300_GNU_VTENTRY", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0, /* src_mask */
0, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
/* Standard 24 bit reloc. */
HOWTO (R_MN10300_24,
0,
2,
24,
- FALSE,
+ false,
0,
complain_overflow_bitfield,
bfd_elf_generic_reloc,
"R_MN10300_24",
- FALSE,
+ false,
0xffffff,
0xffffff,
- FALSE),
+ false),
HOWTO (R_MN10300_GOTPC32, /* 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 */
bfd_elf_generic_reloc, /* */
"R_MN10300_GOTPC32", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0xffffffff, /* src_mask */
0xffffffff, /* dst_mask */
- TRUE), /* pcrel_offset */
+ true), /* pcrel_offset */
HOWTO (R_MN10300_GOTPC16, /* 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 */
bfd_elf_generic_reloc, /* */
"R_MN10300_GOTPC16", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0xffff, /* src_mask */
0xffff, /* dst_mask */
- TRUE), /* pcrel_offset */
+ true), /* pcrel_offset */
HOWTO (R_MN10300_GOTOFF32, /* 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, /* */
"R_MN10300_GOTOFF32", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0xffffffff, /* src_mask */
0xffffffff, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
HOWTO (R_MN10300_GOTOFF24, /* type */
0, /* rightshift */
2, /* size (0 = byte, 1 = short, 2 = long) */
24, /* bitsize */
- FALSE, /* pc_relative */
+ false, /* pc_relative */
0, /* bitpos */
complain_overflow_bitfield, /* complain_on_overflow */
bfd_elf_generic_reloc, /* */
"R_MN10300_GOTOFF24", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0xffffff, /* src_mask */
0xffffff, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
HOWTO (R_MN10300_GOTOFF16, /* 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, /* */
"R_MN10300_GOTOFF16", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0xffff, /* src_mask */
0xffff, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
HOWTO (R_MN10300_PLT32, /* 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 */
bfd_elf_generic_reloc, /* */
"R_MN10300_PLT32", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0xffffffff, /* src_mask */
0xffffffff, /* dst_mask */
- TRUE), /* pcrel_offset */
+ true), /* pcrel_offset */
HOWTO (R_MN10300_PLT16, /* 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 */
bfd_elf_generic_reloc, /* */
"R_MN10300_PLT16", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0xffff, /* src_mask */
0xffff, /* dst_mask */
- TRUE), /* pcrel_offset */
+ true), /* pcrel_offset */
HOWTO (R_MN10300_GOT32, /* 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, /* */
"R_MN10300_GOT32", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0xffffffff, /* src_mask */
0xffffffff, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
HOWTO (R_MN10300_GOT24, /* type */
0, /* rightshift */
2, /* size (0 = byte, 1 = short, 2 = long) */
24, /* bitsize */
- FALSE, /* pc_relative */
+ false, /* pc_relative */
0, /* bitpos */
complain_overflow_bitfield, /* complain_on_overflow */
bfd_elf_generic_reloc, /* */
"R_MN10300_GOT24", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0xffffffff, /* src_mask */
0xffffffff, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
HOWTO (R_MN10300_GOT16, /* 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, /* */
"R_MN10300_GOT16", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0xffffffff, /* src_mask */
0xffffffff, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
HOWTO (R_MN10300_COPY, /* 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, /* */
"R_MN10300_COPY", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0xffffffff, /* src_mask */
0xffffffff, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
HOWTO (R_MN10300_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, /* */
"R_MN10300_GLOB_DAT", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0xffffffff, /* src_mask */
0xffffffff, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
HOWTO (R_MN10300_JMP_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, /* */
"R_MN10300_JMP_SLOT", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0xffffffff, /* src_mask */
0xffffffff, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
HOWTO (R_MN10300_RELATIVE, /* 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, /* */
"R_MN10300_RELATIVE", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0xffffffff, /* src_mask */
0xffffffff, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
HOWTO (R_MN10300_TLS_GD, /* 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, /* */
"R_MN10300_TLS_GD", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0xffffffff, /* src_mask */
0xffffffff, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
HOWTO (R_MN10300_TLS_LD, /* 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, /* */
"R_MN10300_TLS_LD", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0xffffffff, /* src_mask */
0xffffffff, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
HOWTO (R_MN10300_TLS_LDO, /* 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, /* */
"R_MN10300_TLS_LDO", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0xffffffff, /* src_mask */
0xffffffff, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
HOWTO (R_MN10300_TLS_GOTIE, /* 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, /* */
"R_MN10300_TLS_GOTIE", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0xffffffff, /* src_mask */
0xffffffff, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
HOWTO (R_MN10300_TLS_IE, /* 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, /* */
"R_MN10300_TLS_IE", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0xffffffff, /* src_mask */
0xffffffff, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
HOWTO (R_MN10300_TLS_LE, /* 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, /* */
"R_MN10300_TLS_LE", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0xffffffff, /* src_mask */
0xffffffff, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
HOWTO (R_MN10300_TLS_DTPMOD, /* 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, /* */
"R_MN10300_TLS_DTPMOD", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0xffffffff, /* src_mask */
0xffffffff, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
HOWTO (R_MN10300_TLS_DTPOFF, /* 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, /* */
"R_MN10300_TLS_DTPOFF", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0xffffffff, /* src_mask */
0xffffffff, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
HOWTO (R_MN10300_TLS_TPOFF, /* 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, /* */
"R_MN10300_TLS_TPOFF", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0xffffffff, /* src_mask */
0xffffffff, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
HOWTO (R_MN10300_SYM_DIFF, /* type */
0, /* rightshift */
2, /* size (0 = byte, 1 = short, 2 = long) */
32, /* bitsize */
- FALSE, /* pc_relative */
+ false, /* pc_relative */
0, /* bitpos */
complain_overflow_dont,/* complain_on_overflow */
- NULL, /* special handler. */
+ NULL, /* special handler. */
"R_MN10300_SYM_DIFF", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0xffffffff, /* src_mask */
0xffffffff, /* dst_mask */
- FALSE), /* pcrel_offset */
+ false), /* pcrel_offset */
HOWTO (R_MN10300_ALIGN, /* type */
0, /* rightshift */
0, /* size (0 = byte, 1 = short, 2 = long) */
32, /* bitsize */
- FALSE, /* pc_relative */
+ false, /* pc_relative */
0, /* bitpos */
complain_overflow_dont,/* complain_on_overflow */
- NULL, /* special handler. */
+ NULL, /* special handler. */
"R_MN10300_ALIGN", /* name */
- FALSE, /* partial_inplace */
+ false, /* partial_inplace */
0, /* src_mask */
0, /* dst_mask */
- FALSE) /* pcrel_offset */
+ false) /* pcrel_offset */
};
struct mn10300_reloc_map
/* Create the GOT section. */
-static bfd_boolean
+static bool
_bfd_mn10300_elf_create_got_section (bfd * abfd,
struct bfd_link_info * info)
{
/* This function may be called more than once. */
htab = elf_hash_table (info);
if (htab->sgot != NULL)
- return TRUE;
+ return true;
switch (bed->s->arch_size)
{
default:
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
htab->splt = s;
if (s == NULL
- || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
- return FALSE;
+ || !bfd_set_section_alignment (s, bed->plt_alignment))
+ return false;
/* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
.plt section. */
"_PROCEDURE_LINKAGE_TABLE_");
htab->hplt = h;
if (h == NULL)
- return FALSE;
+ return false;
}
s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
htab->sgot = s;
if (s == NULL
- || ! bfd_set_section_alignment (abfd, s, ptralign))
- return FALSE;
+ || !bfd_set_section_alignment (s, ptralign))
+ return false;
if (bed->want_got_plt)
{
s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags);
htab->sgotplt = s;
if (s == NULL
- || ! bfd_set_section_alignment (abfd, s, ptralign))
- return FALSE;
+ || !bfd_set_section_alignment (s, ptralign))
+ return false;
}
/* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
h = _bfd_elf_define_linkage_sym (abfd, info, s, "_GLOBAL_OFFSET_TABLE_");
htab->hgot = h;
if (h == NULL)
- return FALSE;
+ return false;
/* The first bit of the global offset table is the header. */
s->size += bed->got_header_size;
- return TRUE;
+ return true;
}
static reloc_howto_type *
/* Set the howto pointer for an MN10300 ELF reloc. */
-static void
-mn10300_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
+static bool
+mn10300_info_to_howto (bfd *abfd,
arelent *cache_ptr,
Elf_Internal_Rela *dst)
{
unsigned int r_type;
r_type = ELF32_R_TYPE (dst->r_info);
- BFD_ASSERT (r_type < (unsigned int) R_MN10300_MAX);
+ if (r_type >= R_MN10300_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 = elf_mn10300_howto_table + r_type;
+ return true;
}
static int
-elf_mn10300_tls_transition (struct bfd_link_info * info,
- int r_type,
+elf_mn10300_tls_transition (struct bfd_link_info * info,
+ int r_type,
struct elf_link_hash_entry * h,
- asection * sec,
- bfd_boolean counting)
+ asection * sec,
+ bool counting)
{
- bfd_boolean is_local;
+ bool is_local;
if (r_type == R_MN10300_TLS_GD
&& h != NULL
&& elf_mn10300_hash_entry (h)->tls_type == GOT_TLS_IE)
return R_MN10300_TLS_GOTIE;
- if (info->shared)
+ if (bfd_link_pic (info))
return r_type;
if (! (sec->flags & SEC_CODE))
return r_type;
if (! counting && h != NULL && ! elf_hash_table (info)->dynamic_sections_created)
- is_local = TRUE;
+ is_local = true;
else
is_local = SYMBOL_CALLS_LOCAL (info, h);
this reloc and the PLT reloc. */
static int
-mn10300_do_tls_transition (bfd * input_bfd,
- unsigned int r_type,
- unsigned int tls_r_type,
- bfd_byte * contents,
- bfd_vma offset)
+mn10300_do_tls_transition (bfd * input_bfd,
+ unsigned int r_type,
+ unsigned int tls_r_type,
+ bfd_byte * contents,
+ bfd_vma offset)
{
bfd_byte *op = contents + offset;
int gotreg = 0;
accordingly, copying the operands as needed. The conversions
we do are as follows (IE,GOTIE,LE):
- 1111 1100 1010 01Dn [-- abs32 --] MOV (x@indntpoff),Dn
- 1111 1100 0000 DnAm [-- abs32 --] MOV (x@gotntpoff,Am),Dn
- 1111 1100 1100 11Dn [-- abs32 --] MOV x@tpoff,Dn
+ 1111 1100 1010 01Dn [-- abs32 --] MOV (x@indntpoff),Dn
+ 1111 1100 0000 DnAm [-- abs32 --] MOV (x@gotntpoff,Am),Dn
+ 1111 1100 1100 11Dn [-- abs32 --] MOV x@tpoff,Dn
- 1111 1100 1010 00An [-- abs32 --] MOV (x@indntpoff),An
- 1111 1100 0010 AnAm [-- abs32 --] MOV (x@gotntpoff,Am),An
- 1111 1100 1101 11An [-- abs32 --] MOV x@tpoff,An
+ 1111 1100 1010 00An [-- abs32 --] MOV (x@indntpoff),An
+ 1111 1100 0010 AnAm [-- abs32 --] MOV (x@gotntpoff,Am),An
+ 1111 1100 1101 11An [-- abs32 --] MOV x@tpoff,An
1111 1110 0000 1110 Rnnn Xxxx [-- abs32 --] MOV (x@indntpoff),Rn
1111 1110 0000 1010 Rnnn Rmmm [-- abs32 --] MOV (x@indntpoff,Rm),Rn
break;
default:
- (*_bfd_error_handler)
- (_("%s: Unsupported transition from %s to %s"),
- bfd_get_filename (input_bfd),
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: unsupported transition from %s to %s"),
+ input_bfd,
elf_mn10300_howto_table[r_type].name,
elf_mn10300_howto_table[tls_r_type].name);
break;
Since we don't do .gots or .plts, we just need to consider the
virtual table relocs for gc. */
-static bfd_boolean
+static bool
mn10300_elf_check_relocs (bfd *abfd,
struct bfd_link_info *info,
asection *sec,
const Elf_Internal_Rela *relocs)
{
struct elf32_mn10300_link_hash_table * htab = elf32_mn10300_hash_table (info);
- bfd_boolean sym_diff_reloc_seen;
+ bool sym_diff_reloc_seen;
Elf_Internal_Shdr *symtab_hdr;
Elf_Internal_Sym * isymbuf = NULL;
struct elf_link_hash_entry **sym_hashes;
asection * sgot;
asection * srelgot;
asection * sreloc;
- bfd_boolean result = FALSE;
+ bool result = false;
sgot = NULL;
srelgot = NULL;
sreloc = NULL;
- if (info->relocatable)
- return TRUE;
+ if (bfd_link_relocatable (info))
+ return true;
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
dynobj = elf_hash_table (info)->dynobj;
local_got_offsets = elf_local_got_offsets (abfd);
rel_end = relocs + sec->reloc_count;
- sym_diff_reloc_seen = FALSE;
+ sym_diff_reloc_seen = false;
for (rel = relocs; rel < rel_end; rel++)
{
}
r_type = ELF32_R_TYPE (rel->r_info);
- r_type = elf_mn10300_tls_transition (info, r_type, h, sec, TRUE);
+ r_type = elf_mn10300_tls_transition (info, r_type, h, sec, true);
/* Some relocs require a global offset table. */
if (dynobj == NULL)
/* This relocation describes which C++ vtable entries are actually
used. Record for later use during GC. */
case R_MN10300_GNU_VTENTRY:
- BFD_ASSERT (h != NULL);
- if (h != NULL
- && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
+ if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
goto fail;
break;
case R_MN10300_TLS_IE:
case R_MN10300_TLS_GOTIE:
- if (info->shared)
+ if (bfd_link_pic (info))
info->flags |= DF_STATIC_TLS;
/* Fall through */
case R_MN10300_TLS_IE:
case R_MN10300_TLS_GOTIE: tls_type = GOT_TLS_IE; break;
case R_MN10300_TLS_GD: tls_type = GOT_TLS_GD; break;
- default: tls_type = GOT_NORMAL; break;
- }
-
- if (sgot == NULL)
- {
- sgot = htab->root.sgot;
- BFD_ASSERT (sgot != NULL);
+ default: tls_type = GOT_NORMAL; break;
}
- 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))
- goto fail;
- }
- }
+ sgot = htab->root.sgot;
+ srelgot = htab->root.srelgot;
+ BFD_ASSERT (sgot != NULL && srelgot != NULL);
if (r_type == R_MN10300_TLS_LD)
{
/* Transition GD->IE. */
tls_type = GOT_TLS_IE;
else
- (*_bfd_error_handler)
- (_("%B: %s' accessed both as normal and thread local symbol"),
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: %s' accessed both as normal and thread local symbol"),
abfd, h ? h->root.root.string : "<local>");
}
local_got_offsets[r_symndx] = sgot->size;
- if (info->shared)
+ if (bfd_link_pic (info))
{
/* If we are generating a shared object, we need to
output a R_MN10300_RELATIVE reloc so that the dynamic
break;
case R_MN10300_SYM_DIFF:
- sym_diff_reloc_seen = TRUE;
+ sym_diff_reloc_seen = true;
break;
case R_MN10300_32:
need_shared_relocs:
/* If we are creating a shared library, then we
need to copy the reloc into the shared library. */
- if (info->shared
+ if (bfd_link_pic (info)
&& (sec->flags & SEC_ALLOC) != 0
/* Do not generate a dynamic reloc for a
reloc associated with a SYM_DIFF operation. */
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)
goto fail;
}
}
if (ELF32_R_TYPE (rel->r_info) != R_MN10300_SYM_DIFF)
- sym_diff_reloc_seen = FALSE;
+ sym_diff_reloc_seen = false;
}
- result = TRUE;
+ result = true;
fail:
- if (isymbuf != NULL)
+ if (symtab_hdr->contents != (unsigned char *) isymbuf)
free (isymbuf);
return result;
struct elf32_mn10300_link_hash_table * htab = elf32_mn10300_hash_table (info);
static asection * sym_diff_section;
static bfd_vma sym_diff_value;
- bfd_boolean is_sym_diff_reloc;
+ bool is_sym_diff_reloc;
unsigned long r_type = howto->type;
bfd_byte * hit_data = contents + offset;
bfd * dynobj;
case R_MN10300_GOTOFF32:
case R_MN10300_GOTOFF24:
case R_MN10300_GOTOFF16:
- if (info->shared
+ if (bfd_link_pic (info)
&& (input_section->flags & SEC_ALLOC) != 0
&& h != NULL
&& ! SYMBOL_REFERENCES_LOCAL (info, h))
return bfd_reloc_dangerous;
+ /* Fall through. */
case R_MN10300_GOT32:
/* Issue 2052223:
Taking the address of a protected function in a shared library
is illegal. Issue an error message here. */
- if (info->shared
+ if (bfd_link_pic (info)
&& (input_section->flags & SEC_ALLOC) != 0
&& h != NULL
&& ELF_ST_VISIBILITY (h->other) == STV_PROTECTED
return bfd_reloc_dangerous;
}
- is_sym_diff_reloc = FALSE;
+ is_sym_diff_reloc = false;
if (sym_diff_section != NULL)
{
BFD_ASSERT (sym_diff_section == input_section);
&& strcmp (input_section->name, ".debug_loc") == 0)
value = 1;
sym_diff_section = NULL;
- is_sym_diff_reloc = TRUE;
+ is_sym_diff_reloc = true;
break;
default:
return bfd_reloc_ok;
case R_MN10300_32:
- if (info->shared
+ if (bfd_link_pic (info)
/* Do not generate relocs when an R_MN10300_32 has been used
with an R_MN10300_SYM_DIFF to compute a difference of two
symbols. */
- && is_sym_diff_reloc == FALSE
+ && !is_sym_diff_reloc
/* Also, do not generate a reloc when the symbol associated
with the R_MN10300_32 reloc is absolute - there is no
need for a run time computation in this case. */
&& (input_section->flags & SEC_ALLOC) != 0)
{
Elf_Internal_Rela outrel;
- 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);
+ (input_bfd, input_section, /*rela?*/ true);
if (sreloc == NULL)
- return FALSE;
+ return false;
}
- skip = FALSE;
+ skip = false;
outrel.r_offset = _bfd_elf_section_offset (input_bfd, info,
input_section, offset);
if (outrel.r_offset == (bfd_vma) -1)
- skip = TRUE;
+ skip = true;
outrel.r_offset += (input_section->output_section->vma
+ input_section->output_offset);
if (skip)
{
memset (&outrel, 0, sizeof outrel);
- relocate = FALSE;
+ relocate = false;
}
else
{
if (h == NULL
|| SYMBOL_REFERENCES_LOCAL (info, h))
{
- relocate = TRUE;
+ relocate = true;
outrel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE);
outrel.r_addend = value + addend;
}
else
{
BFD_ASSERT (h->dynindx != -1);
- relocate = FALSE;
+ relocate = false;
outrel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_32);
outrel.r_addend = value + addend;
}
if (!htab->tls_ldm_got.rel_emitted)
{
- asection * srelgot = bfd_get_linker_section (dynobj, ".rela.got");
+ asection *srelgot = htab->root.srelgot;
Elf_Internal_Rela rel;
BFD_ASSERT (srelgot != NULL);
{
bfd_put_32 (output_bfd, value, sgot->contents + off);
- if (info->shared)
+ if (bfd_link_pic (info))
{
- asection * srelgot;
+ asection *srelgot = htab->root.srelgot;;
Elf_Internal_Rela outrel;
- srelgot = bfd_get_linker_section (dynobj, ".rela.got");
BFD_ASSERT (srelgot != NULL);
outrel.r_offset = (sgot->output_section->vma
\f
/* Relocate an MN10300 ELF section. */
-static bfd_boolean
+static int
mn10300_elf_relocate_section (bfd *output_bfd,
struct bfd_link_info *info,
bfd *input_bfd,
bfd_vma relocation;
bfd_reloc_status_type r;
int tls_r_type;
- bfd_boolean unresolved_reloc = FALSE;
- bfd_boolean warned;
+ bool unresolved_reloc = false;
+ bool warned, ignored;
struct elf_link_hash_entry * hh;
relocation = 0;
RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
r_symndx, symtab_hdr, sym_hashes,
hh, sec, relocation,
- unresolved_reloc, warned);
+ unresolved_reloc, warned, ignored);
}
h = elf_mn10300_hash_entry (hh);
tls_r_type = elf_mn10300_tls_transition (info, r_type, hh, input_section, 0);
if (tls_r_type != r_type)
{
- bfd_boolean had_plt;
+ bool had_plt;
had_plt = mn10300_do_tls_transition (input_bfd, r_type, tls_r_type,
contents, rel->r_offset);
&& elf_hash_table (info)->dynamic_sections_created
&& !SYMBOL_REFERENCES_LOCAL (info, hh))
|| (r_type == R_MN10300_32
+ && !SYMBOL_REFERENCES_LOCAL (info, hh)
/* _32 relocs in executables force _COPY relocs,
such that the address of the symbol ends up
being local. */
- && !info->executable
- && !SYMBOL_REFERENCES_LOCAL (info, hh)
- && ((input_section->flags & SEC_ALLOC) != 0
+ && (((input_section->flags & SEC_ALLOC) != 0
+ && !bfd_link_executable (info))
/* DWARF will emit R_MN10300_32 relocations
in its sections against symbols defined
externally in shared libraries. We can't
obscure cases sec->output_section will be NULL. */
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(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB(%pA+%#" PRIx64 "): "
+ "unresolvable %s relocation against symbol `%s'"),
input_bfd,
input_section,
- (long) rel->r_offset,
+ (uint64_t) rel->r_offset,
howto->name,
h->root.root.root.string);
}
RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
rel, 1, relend, howto, 0, contents);
- if (info->relocatable)
+ if (bfd_link_relocatable (info))
continue;
r = mn10300_elf_final_link_relocate (howto, input_bfd, output_bfd,
name = (bfd_elf_string_from_elf_section
(input_bfd, symtab_hdr->sh_link, sym->st_name));
if (name == NULL || *name == '\0')
- name = bfd_section_name (input_bfd, sec);
+ name = bfd_section_name (sec);
}
switch (r)
{
case bfd_reloc_overflow:
- if (! ((*info->callbacks->reloc_overflow)
- (info, (h ? &h->root.root : NULL), name,
- howto->name, (bfd_vma) 0, input_bfd,
- input_section, rel->r_offset)))
- return FALSE;
+ (*info->callbacks->reloc_overflow)
+ (info, (h ? &h->root.root : NULL), name, howto->name,
+ (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
break;
case bfd_reloc_undefined:
- if (! ((*info->callbacks->undefined_symbol)
- (info, name, input_bfd, input_section,
- rel->r_offset, TRUE)))
- return FALSE;
+ (*info->callbacks->undefined_symbol)
+ (info, name, input_bfd, input_section, rel->r_offset, true);
break;
case bfd_reloc_outofrange:
msg = _("error: inappropriate relocation type for shared"
" library (did you forget -fpic?)");
else if (r_type == R_MN10300_GOT32)
- msg = _("%B: taking the address of protected function"
+ /* xgettext:c-format */
+ msg = _("%pB: taking the address of protected function"
" '%s' cannot be done when making a shared library");
else
msg = _("internal error: suspicious relocation type used"
common_error:
_bfd_error_handler (msg, input_bfd, name);
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
}
}
- return TRUE;
+ return true;
}
/* Finish initializing one hash table entry. */
-static bfd_boolean
+static bool
elf32_mn10300_finish_hash_table_entry (struct bfd_hash_entry *gen_entry,
void * in_args)
{
/* If we already know we want to convert "call" to "calls" for calls
to this symbol, then return now. */
if (entry->flags == MN10300_CONVERT_CALL_TO_CALLS)
- return TRUE;
+ return true;
/* If there are no named calls to this symbol, or there's nothing we
can move from the function itself into the "call" instruction,
/* Make a note that we should convert "call" instructions to "calls"
instructions for calls to this symbol. */
entry->flags |= MN10300_CONVERT_CALL_TO_CALLS;
- return TRUE;
+ return true;
}
/* We may be able to move some instructions from the function itself into
entry->flags |= MN10300_CONVERT_CALL_TO_CALLS;
/* This routine never fails. */
- return TRUE;
+ return true;
}
/* Used to count hash table entries. */
-static bfd_boolean
+static bool
elf32_mn10300_count_hash_table_entries (struct bfd_hash_entry *gen_entry ATTRIBUTE_UNUSED,
void * in_args)
{
int *count = (int *) in_args;
(*count) ++;
- return TRUE;
+ return true;
}
/* Used to enumerate hash table entries into a linear array. */
-static bfd_boolean
+static bool
elf32_mn10300_list_hash_table_entries (struct bfd_hash_entry *gen_entry,
void * in_args)
{
**ptr = gen_entry;
(*ptr) ++;
- return TRUE;
+ return true;
}
/* Used to sort the array created by the above. */
/* Delete some bytes from a section while relaxing. */
-static bfd_boolean
+static bool
mn10300_elf_relax_delete_bytes (bfd *abfd,
asection *sec,
bfd_vma addr,
if (ELF32_R_TYPE ((irelend - 1)->r_info) == (int) R_MN10300_ALIGN)
--irelend;
- /* The deletion must stop at the next ALIGN reloc for an aligment
+ /* The deletion must stop at the next ALIGN reloc for an alignment
power larger than, or not a multiple of, the number of bytes we
are deleting. */
for (; irel < irelend; irel++)
{
- int alignment = 1 << irel->r_addend;
-
if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_ALIGN
&& irel->r_offset > addr
- && irel->r_offset < toaddr
- && (count < alignment
- || alignment % count != 0))
+ && irel->r_offset < toaddr)
{
- irelalign = irel;
- toaddr = irel->r_offset;
- break;
+ int alignment = 1 << irel->r_addend;
+
+ if (count < alignment
+ || alignment % count != 0)
+ {
+ irelalign = irel;
+ toaddr = irel->r_offset;
+ break;
+ }
}
}
}
}
}
- return TRUE;
+ return true;
}
/* Return TRUE if a symbol exists at the given address, else return
FALSE. */
-static bfd_boolean
+static bool
mn10300_elf_symbol_address_p (bfd *abfd,
asection *sec,
Elf_Internal_Sym *isym,
for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
if (isym->st_shndx == sec_shndx
&& isym->st_value == addr)
- return TRUE;
+ return true;
symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
- symtab_hdr->sh_info);
|| sym_hash->root.type == bfd_link_hash_defweak)
&& sym_hash->root.u.def.section == sec
&& sym_hash->root.u.def.value == addr)
- return TRUE;
+ return true;
}
- return FALSE;
+ return false;
}
/* This function handles relaxing for the mn10300.
There are quite a few relaxing opportunities available on the mn10300:
- * calls:32 -> calls:16 2 bytes
+ * calls:32 -> calls:16 2 bytes
* call:32 -> call:16 2 bytes
* call:32 -> calls:32 1 byte
We don't handle imm16->imm8 or d16->d8 as they're very rare
and somewhat more difficult to support. */
-static bfd_boolean
+static bool
mn10300_elf_relax_section (bfd *abfd,
asection *sec,
struct bfd_link_info *link_info,
- bfd_boolean *again)
+ bool *again)
{
Elf_Internal_Shdr *symtab_hdr;
Elf_Internal_Rela *internal_relocs = NULL;
asection *section = sec;
bfd_vma align_gap_adjustment;
- if (link_info->relocatable)
+ if (bfd_link_relocatable (link_info))
(*link_info->callbacks->einfo)
(_("%P%F: --relax and -r may not be used together\n"));
/* Assume nothing changes. */
- *again = FALSE;
+ *again = false;
/* We need a pointer to the mn10300 specific hash table. */
hash_table = elf32_mn10300_hash_table (link_info);
if (hash_table == NULL)
- return FALSE;
+ return false;
/* Initialize fields in each hash table entry the first time through. */
if ((hash_table->flags & MN10300_HASH_ENTRIES_INITIALIZED) == 0)
/* Iterate over all the input bfds. */
for (input_bfd = link_info->input_bfds;
input_bfd != NULL;
- input_bfd = input_bfd->link_next)
+ input_bfd = input_bfd->link.next)
{
/* We're going to need all the symbols for each bfd. */
symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
/* A local symbol. */
Elf_Internal_Sym *isym;
struct elf_link_hash_table *elftab;
- bfd_size_type amt;
+ size_t amt;
isym = isymbuf + r_index;
if (isym->st_shndx == SHN_UNDEF)
elftab = &hash_table->static_hash_table->root;
hash = ((struct elf32_mn10300_link_hash_entry *)
elf_link_hash_lookup (elftab, sym_name,
- TRUE, TRUE, FALSE));
+ true, true, false));
free (new_name);
}
else
&& ELF_ST_TYPE (isym->st_info) == STT_FUNC)
{
struct elf_link_hash_table *elftab;
- bfd_size_type amt;
+ size_t amt;
struct elf_link_hash_entry **lhashes = hashes;
/* Skip a local symbol if it aliases a
elftab = &hash_table->static_hash_table->root;
hash = ((struct elf32_mn10300_link_hash_entry *)
elf_link_hash_lookup (elftab, sym_name,
- TRUE, TRUE, FALSE));
+ true, true, false));
free (new_name);
compute_function_info (input_bfd, hash,
isym->st_value, contents);
}
/* Cache or free any memory we allocated for the relocs. */
- if (internal_relocs != NULL
- && elf_section_data (section)->relocs != internal_relocs)
+ if (elf_section_data (section)->relocs != internal_relocs)
free (internal_relocs);
internal_relocs = NULL;
a "call" instruction. */
for (input_bfd = link_info->input_bfds;
input_bfd != NULL;
- input_bfd = input_bfd->link_next)
+ input_bfd = input_bfd->link.next)
{
/* We're going to need all the local symbols for each bfd. */
symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
const char *sym_name;
char *new_name;
struct elf_link_hash_table *elftab;
- bfd_size_type amt;
+ size_t amt;
if (isym->st_shndx != sec_shndx)
continue;
elftab = & hash_table->static_hash_table->root;
sym_hash = (struct elf32_mn10300_link_hash_entry *)
elf_link_hash_lookup (elftab, sym_name,
- FALSE, FALSE, FALSE);
+ false, false, false);
free (new_name);
if (sym_hash == NULL)
/* Something changed. Not strictly necessary, but
may lead to more relaxing opportunities. */
- *again = TRUE;
+ *again = true;
}
}
/* Something changed. Not strictly necessary, but
may lead to more relaxing opportunities. */
- *again = TRUE;
+ *again = true;
}
}
/* Cache or free any memory we allocated for the relocs. */
- if (internal_relocs != NULL
- && elf_section_data (section)->relocs != internal_relocs)
+ if (elf_section_data (section)->relocs != internal_relocs)
free (internal_relocs);
internal_relocs = NULL;
/* We don't have to do anything for a relocatable link, if
this section does not have relocs, or if this is not a
code section. */
- if (link_info->relocatable
+ if (bfd_link_relocatable (link_info)
|| (sec->flags & SEC_RELOC) == 0
|| sec->reloc_count == 0
|| (sec->flags & SEC_CODE) == 0)
- return TRUE;
+ return true;
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
h = (struct elf32_mn10300_link_hash_entry *)
elf_link_hash_lookup (&hash_table->static_hash_table->root,
- sym_name, FALSE, FALSE, FALSE);
+ sym_name, false, false, false);
free (new_name);
}
else
/* That will change things, so, we should relax again.
Note that this is not required, and it may be slow. */
- *again = TRUE;
+ *again = true;
}
}
else if (h)
/* That will change things, so, we should relax again.
Note that this is not required, and it may be slow. */
- *again = TRUE;
+ *again = true;
}
}
/* That will change things, so, we should relax again.
Note that this is not required, and it may be slow. */
- *again = TRUE;
+ *again = true;
}
}
else if (h)
/* That will change things, so, we should relax again.
Note that this is not required, and it may be slow. */
- *again = TRUE;
+ *again = true;
}
}
/* That will change things, so, we should relax again.
Note that this is not required, and it may be slow. */
- *again = TRUE;
+ *again = true;
}
/* Try to turn a 24 immediate, displacement or absolute address
/* That will change things, so, we should relax
again. Note that this is not required, and it
may be slow. */
- *again = TRUE;
+ *again = true;
break;
}
}
/* See if the value will fit in 24 bits.
We allow any 16bit match here. We prune those we can't
handle below. */
- if ((long) value < 0x7fffff && (long) value > -0x800000)
+ if (value + 0x800000 < 0x1000000 && irel->r_offset >= 3)
{
unsigned char code;
/* That will change things, so, we should relax
again. Note that this is not required, and it
may be slow. */
- *again = TRUE;
+ *again = true;
break;
}
}
/* See if the value will fit in 16 bits.
We allow any 16bit match here. We prune those we can't
handle below. */
- if ((long) value < 0x7fff && (long) value > -0x8000)
+ if (value + 0x8000 < 0x10000 && irel->r_offset >= 2)
{
unsigned char code;
/* That will change things, so, we should relax again.
Note that this is not required, and it may be slow. */
- *again = TRUE;
+ *again = true;
break;
}
else if ((code & 0xf0) == 0x80
/* That will change things, so, we should relax again.
Note that this is not required, and it may be slow. */
- *again = TRUE;
+ *again = true;
break;
/* mov am,(abs32) -> mov am,(abs16)
/* That will change things, so, we should relax again.
Note that this is not required, and it may be slow. */
- *again = TRUE;
+ *again = true;
break;
}
else if ((code & 0xf0) < 0xf0)
/* That will change things, so, we should relax again.
Note that this is not required, and it may be slow. */
- *again = TRUE;
+ *again = true;
break;
/* mov (abs32),an -> mov (abs16),an
/* That will change things, so, we should relax again.
Note that this is not required, and it may be slow. */
- *again = TRUE;
+ *again = true;
break;
}
else if (code == 0xfe)
/* That will change things, so, we should relax again.
Note that this is not required, and it may be slow. */
- *again = TRUE;
+ *again = true;
break;
}
}
}
}
- if (internal_relocs != NULL
- && elf_section_data (sec)->relocs != internal_relocs)
+ if (elf_section_data (sec)->relocs != internal_relocs)
free (internal_relocs);
- return TRUE;
+ return true;
error_return:
- if (isymbuf != NULL
- && symtab_hdr->contents != (unsigned char *) isymbuf)
+ if (symtab_hdr->contents != (unsigned char *) isymbuf)
free (isymbuf);
- if (contents != NULL
- && elf_section_data (section)->this_hdr.contents != contents)
+ if (elf_section_data (section)->this_hdr.contents != contents)
free (contents);
- if (internal_relocs != NULL
- && elf_section_data (section)->relocs != internal_relocs)
+ if (elf_section_data (section)->relocs != internal_relocs)
free (internal_relocs);
- return FALSE;
+ return false;
}
/* This is a version of bfd_generic_get_relocated_section_contents
struct bfd_link_info *link_info,
struct bfd_link_order *link_order,
bfd_byte *data,
- bfd_boolean relocatable,
+ bool relocatable,
asymbol **symbols)
{
Elf_Internal_Shdr *symtab_hdr;
bfd_size_type amt;
internal_relocs = _bfd_elf_link_read_relocs (input_bfd, input_section,
- NULL, NULL, FALSE);
+ NULL, NULL, false);
if (internal_relocs == NULL)
goto error_return;
isymbuf, sections))
goto error_return;
- if (sections != NULL)
- free (sections);
- if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
+ free (sections);
+ if (symtab_hdr->contents != (unsigned char *) isymbuf)
free (isymbuf);
if (internal_relocs != elf_section_data (input_section)->relocs)
free (internal_relocs);
return data;
error_return:
- if (sections != NULL)
- free (sections);
- if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
+ free (sections);
+ if (symtab_hdr->contents != (unsigned char *) isymbuf)
free (isymbuf);
- if (internal_relocs != NULL
- && internal_relocs != elf_section_data (input_section)->relocs)
+ if (internal_relocs != elf_section_data (input_section)->relocs)
free (internal_relocs);
return NULL;
}
}
static void
-_bfd_mn10300_copy_indirect_symbol (struct bfd_link_info * info,
- struct elf_link_hash_entry * dir,
- struct elf_link_hash_entry * ind)
+_bfd_mn10300_copy_indirect_symbol (struct bfd_link_info * info,
+ struct elf_link_hash_entry * dir,
+ struct elf_link_hash_entry * ind)
{
struct elf32_mn10300_link_hash_entry * edir;
struct elf32_mn10300_link_hash_entry * eind;
_bfd_elf_link_hash_copy_indirect (info, dir, ind);
}
+/* Destroy an mn10300 ELF linker hash table. */
+
+static void
+elf32_mn10300_link_hash_table_free (bfd *obfd)
+{
+ struct elf32_mn10300_link_hash_table *ret
+ = (struct elf32_mn10300_link_hash_table *) obfd->link.hash;
+
+ obfd->link.hash = &ret->static_hash_table->root.root;
+ _bfd_elf_link_hash_table_free (obfd);
+ obfd->is_linker_output = true;
+ obfd->link.hash = &ret->root.root;
+ _bfd_elf_link_hash_table_free (obfd);
+}
+
/* Create an mn10300 ELF linker hash table. */
static struct bfd_link_hash_table *
elf32_mn10300_link_hash_table_create (bfd *abfd)
{
struct elf32_mn10300_link_hash_table *ret;
- bfd_size_type amt = sizeof (* ret);
+ size_t amt = sizeof (* ret);
ret = bfd_zmalloc (amt);
if (ret == NULL)
return NULL;
- if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
- elf32_mn10300_link_hash_newfunc,
- sizeof (struct elf32_mn10300_link_hash_entry),
- MN10300_ELF_DATA))
- {
- free (ret);
- return NULL;
- }
-
- ret->tls_ldm_got.offset = -1;
-
amt = sizeof (struct elf_link_hash_table);
ret->static_hash_table = bfd_zmalloc (amt);
if (ret->static_hash_table == NULL)
free (ret);
return NULL;
}
- return & ret->root.root;
-}
-/* Free an mn10300 ELF linker hash table. */
+ abfd->is_linker_output = false;
+ abfd->link.hash = NULL;
+ if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
+ elf32_mn10300_link_hash_newfunc,
+ sizeof (struct elf32_mn10300_link_hash_entry),
+ MN10300_ELF_DATA))
+ {
+ abfd->is_linker_output = true;
+ abfd->link.hash = &ret->static_hash_table->root.root;
+ _bfd_elf_link_hash_table_free (abfd);
+ free (ret);
+ return NULL;
+ }
+ ret->root.root.hash_table_free = elf32_mn10300_link_hash_table_free;
-static void
-elf32_mn10300_link_hash_table_free (struct bfd_link_hash_table *hash)
-{
- struct elf32_mn10300_link_hash_table *ret
- = (struct elf32_mn10300_link_hash_table *) hash;
+ ret->tls_ldm_got.offset = -1;
- _bfd_elf_link_hash_table_free
- ((struct bfd_link_hash_table *) ret->static_hash_table);
- _bfd_elf_link_hash_table_free
- ((struct bfd_link_hash_table *) ret);
+ return & ret->root.root;
}
static unsigned long
file. This gets the MN10300 architecture right based on the machine
number. */
-static void
-_bfd_mn10300_elf_final_write_processing (bfd *abfd,
- bfd_boolean linker ATTRIBUTE_UNUSED)
+static bool
+_bfd_mn10300_elf_final_write_processing (bfd *abfd)
{
unsigned long val;
elf_elfheader (abfd)->e_flags &= ~ (EF_MN10300_MACH);
elf_elfheader (abfd)->e_flags |= val;
+ return _bfd_elf_final_write_processing (abfd);
}
-static bfd_boolean
+static bool
_bfd_mn10300_elf_object_p (bfd *abfd)
{
bfd_default_set_arch_mach (abfd, bfd_arch_mn10300,
elf_mn10300_mach (elf_elfheader (abfd)->e_flags));
- return TRUE;
+ return true;
}
/* Merge backend specific data from an object file to the output
object file when linking. */
-static bfd_boolean
-_bfd_mn10300_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
+static bool
+_bfd_mn10300_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
{
+ bfd *obfd = info->output_bfd;
+
if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
|| bfd_get_flavour (obfd) != bfd_target_elf_flavour)
- return TRUE;
+ return true;
if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
&& bfd_get_mach (obfd) < bfd_get_mach (ibfd))
{
if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
bfd_get_mach (ibfd)))
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
#define PLT0_ENTRY_SIZE 15
/* Return size of the first PLT entry. */
#define elf_mn10300_sizeof_plt0(info) \
- (info->shared ? PIC_PLT_ENTRY_SIZE : PLT0_ENTRY_SIZE)
+ (bfd_link_pic (info) ? PIC_PLT_ENTRY_SIZE : PLT0_ENTRY_SIZE)
/* Return size of a PLT entry. */
#define elf_mn10300_sizeof_plt(info) \
- (info->shared ? PIC_PLT_ENTRY_SIZE : PLT_ENTRY_SIZE)
+ (bfd_link_pic (info) ? PIC_PLT_ENTRY_SIZE : PLT_ENTRY_SIZE)
/* Return offset of the PLT0 address in an absolute PLT entry. */
#define elf_mn10300_plt_plt0_offset(info) 16
/* Create dynamic sections when linking against a dynamic object. */
-static bfd_boolean
+static bool
_bfd_mn10300_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
{
flagword flags;
default:
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
/* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
flags | SEC_READONLY);
htab->root.srelplt = s;
if (s == NULL
- || ! bfd_set_section_alignment (abfd, s, ptralign))
- return FALSE;
+ || !bfd_set_section_alignment (s, ptralign))
+ return false;
if (! _bfd_mn10300_elf_create_got_section (abfd, info))
- return FALSE;
+ return false;
if (bed->want_dynbss)
{
s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
SEC_ALLOC | SEC_LINKER_CREATED);
if (s == NULL)
- return FALSE;
+ return false;
/* The .rel[a].bss section holds copy relocs. This section is not
normally needed. We need to create it here, though, so that the
be needed, we can discard it later. We will never need this
section when generating a shared object, since they do not use
copy relocs. */
- if (! info->shared)
+ if (! bfd_link_pic (info))
{
s = bfd_make_section_anyway_with_flags (abfd,
(bed->default_use_rela_p
? ".rela.bss" : ".rel.bss"),
flags | SEC_READONLY);
if (s == NULL
- || ! bfd_set_section_alignment (abfd, s, ptralign))
- return FALSE;
+ || !bfd_set_section_alignment (s, ptralign))
+ return false;
}
}
- return TRUE;
+ return true;
}
\f
/* Adjust a symbol defined by a dynamic object and referenced by a
change the definition to something the rest of the link can
understand. */
-static bfd_boolean
+static bool
_bfd_mn10300_elf_adjust_dynamic_symbol (struct bfd_link_info * info,
struct elf_link_hash_entry * h)
{
/* 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)));
if (h->type == STT_FUNC
|| h->needs_plt)
{
- if (! info->shared
+ if (! bfd_link_pic (info)
&& !h->def_dynamic
&& !h->ref_dynamic)
{
a procedure linkage table, and we can just do a REL32
reloc instead. */
BFD_ASSERT (h->needs_plt);
- 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 = htab->root.splt;
location in the .plt. This is required to make function
pointers compare as equal between the normal executable and
the shared library. */
- if (! info->shared
+ if (! bfd_link_pic (info)
&& !h->def_regular)
{
h->root.u.def.section = s;
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;
}
/* 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
h->needs_copy = 1;
}
- return _bfd_elf_adjust_dynamic_copy (h, s);
+ return _bfd_elf_adjust_dynamic_copy (info, h, s);
}
/* Set the sizes of the dynamic sections. */
-static bfd_boolean
+static bool
_bfd_mn10300_elf_size_dynamic_sections (bfd * output_bfd,
struct bfd_link_info * info)
{
struct elf32_mn10300_link_hash_table *htab = elf32_mn10300_hash_table (info);
bfd * dynobj;
asection * s;
- bfd_boolean plt;
- bfd_boolean relocs;
- bfd_boolean reltext;
+ bool relocs;
dynobj = htab->root.dynobj;
BFD_ASSERT (dynobj != NULL);
if (elf_hash_table (info)->dynamic_sections_created)
{
/* Set the contents of the .interp section to the interpreter. */
- if (info->executable)
+ if (bfd_link_executable (info) && !info->nointerp)
{
s = bfd_get_linker_section (dynobj, ".interp");
BFD_ASSERT (s != NULL);
if (htab->tls_ldm_got.refcount > 0)
{
- s = bfd_get_linker_section (dynobj, ".rela.got");
+ s = htab->root.srelgot;
BFD_ASSERT (s != NULL);
s->size += sizeof (Elf32_External_Rela);
}
/* 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;
- reltext = 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 (streq (name, ".plt"))
{
/* Remember whether there is a PLT. */
- plt = s->size != 0;
+ ;
}
- else if (CONST_STRNEQ (name, ".rela"))
+ else if (startswith (name, ".rela"))
{
if (s->size != 0)
{
- asection * target;
-
/* Remember whether there are any reloc sections other
than .rela.plt. */
if (! streq (name, ".rela.plt"))
- {
- const char * outname;
-
- relocs = TRUE;
-
- /* If this relocation section applies to a read only
- section, then we probably need a DT_TEXTREL
- entry. The entries in the .rela.plt section
- really apply to the .got section, which we
- created ourselves and so know is not readonly. */
- outname = bfd_get_section_name (output_bfd,
- s->output_section);
- target = bfd_get_section_by_name (output_bfd, outname + 5);
- if (target != NULL
- && (target->flags & SEC_READONLY) != 0
- && (target->flags & SEC_ALLOC) != 0)
- reltext = 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")
+ else if (! startswith (name, ".got")
&& ! streq (name, ".dynbss"))
/* It's not one of our sections, so don't allocate space. */
continue;
instead of garbage. */
s->contents = 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 _bfd_mn10300_elf_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. */
- if (! info->shared)
- {
- if (!_bfd_elf_add_dynamic_entry (info, DT_DEBUG, 0))
- return FALSE;
- }
-
- if (plt)
- {
- if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0)
- || !_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0)
- || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
- || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0))
- return FALSE;
- }
-
- if (relocs)
- {
- if (!_bfd_elf_add_dynamic_entry (info, DT_RELA, 0)
- || !_bfd_elf_add_dynamic_entry (info, DT_RELASZ, 0)
- || !_bfd_elf_add_dynamic_entry (info, DT_RELAENT,
- sizeof (Elf32_External_Rela)))
- return FALSE;
- }
-
- if (reltext)
- {
- if (!_bfd_elf_add_dynamic_entry (info, DT_TEXTREL, 0))
- return FALSE;
- }
- }
-
- return TRUE;
+ return _bfd_elf_add_dynamic_tags (output_bfd, info, relocs);
}
/* Finish up dynamic symbol handling. We set the contents of various
dynamic sections here. */
-static bfd_boolean
+static bool
_bfd_mn10300_elf_finish_dynamic_symbol (bfd * output_bfd,
struct bfd_link_info * info,
struct elf_link_hash_entry * h,
if (h->plt.offset != (bfd_vma) -1)
{
- asection * splt;
- asection * sgot;
- asection * srel;
- bfd_vma plt_index;
- bfd_vma got_offset;
+ asection * splt;
+ asection * sgot;
+ asection * srel;
+ bfd_vma plt_index;
+ bfd_vma got_offset;
Elf_Internal_Rela rel;
/* This symbol has an entry in the procedure linkage table. Set
splt = htab->root.splt;
sgot = htab->root.sgotplt;
- srel = bfd_get_linker_section (dynobj, ".rela.plt");
+ srel = htab->root.srelplt;
BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
/* Get the index in the procedure linkage table which
got_offset = (plt_index + 3) * 4;
/* Fill in the entry in the procedure linkage table. */
- if (! info->shared)
+ if (! bfd_link_pic (info))
{
memcpy (splt->contents + h->plt.offset, elf_mn10300_plt_entry,
elf_mn10300_sizeof_plt (info));
if (h->got.offset != (bfd_vma) -1)
{
- asection * sgot;
- asection * srel;
+ asection * sgot;
+ asection * srel;
Elf_Internal_Rela rel;
/* This symbol has an entry in the global offset table. Set it up. */
sgot = htab->root.sgot;
- srel = bfd_get_linker_section (dynobj, ".rela.got");
+ srel = htab->root.srelgot;
BFD_ASSERT (sgot != NULL && srel != NULL);
rel.r_offset = (sgot->output_section->vma
the symbol was forced to be local because of a version file.
The entry in the global offset table will already have been
initialized in the relocate_section function. */
- if (info->shared
+ if (bfd_link_pic (info)
&& (info->symbolic || h->dynindx == -1)
&& h->def_regular)
{
if (h->needs_copy)
{
- asection * s;
+ asection * s;
Elf_Internal_Rela rel;
/* This symbol needs a copy reloc. Set it up. */
|| h == elf_hash_table (info)->hgot)
sym->st_shndx = SHN_ABS;
- return TRUE;
+ return true;
}
/* Finish up the dynamic sections. */
-static bfd_boolean
+static bool
_bfd_mn10300_elf_finish_dynamic_sections (bfd * output_bfd,
struct bfd_link_info * info)
{
if (elf_hash_table (info)->dynamic_sections_created)
{
- asection * splt;
+ asection * splt;
Elf32_External_Dyn * dyncon;
Elf32_External_Dyn * dynconend;
for (; dyncon < dynconend; dyncon++)
{
Elf_Internal_Dyn dyn;
- const char * name;
asection * s;
bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
break;
case DT_PLTGOT:
- name = ".got";
+ s = htab->root.sgot;
goto get_vma;
case DT_JMPREL:
- name = ".rela.plt";
+ s = htab->root.srelplt;
get_vma:
- s = bfd_get_section_by_name (output_bfd, name);
- BFD_ASSERT (s != NULL);
- dyn.d_un.d_ptr = s->vma;
+ dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
break;
case DT_PLTRELSZ:
- s = bfd_get_section_by_name (output_bfd, ".rela.plt");
- BFD_ASSERT (s != NULL);
+ s = htab->root.srelplt;
dyn.d_un.d_val = s->size;
bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
break;
-
- case DT_RELASZ:
- /* My reading of the SVR4 ABI indicates that the
- procedure linkage table relocs (DT_JMPREL) should be
- included in the overall relocs (DT_RELA). This is
- what Solaris does. However, UnixWare can not handle
- that case. 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;
}
}
splt = htab->root.splt;
if (splt && splt->size > 0)
{
- if (info->shared)
+ if (bfd_link_pic (info))
{
memcpy (splt->contents, elf_mn10300_pic_plt_entry,
elf_mn10300_sizeof_plt (info));
elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
- return TRUE;
+ return true;
}
/* Classify relocation types, such that combreloc can sort them
/* Allocate space for an MN10300 extension to the bfd elf data structure. */
-static bfd_boolean
+static bool
mn10300_elf_mkobject (bfd *abfd)
{
return bfd_elf_allocate_object (abfd, sizeof (struct elf_mn10300_obj_tdata),
#define bfd_elf32_mkobject mn10300_elf_mkobject
#ifndef ELF_ARCH
-#define TARGET_LITTLE_SYM bfd_elf32_mn10300_vec
+#define TARGET_LITTLE_SYM mn10300_elf32_vec
#define TARGET_LITTLE_NAME "elf32-mn10300"
#define ELF_ARCH bfd_arch_mn10300
#define ELF_TARGET_ID MN10300_ELF_DATA
#endif
#define elf_info_to_howto mn10300_info_to_howto
-#define elf_info_to_howto_rel 0
+#define elf_info_to_howto_rel NULL
#define elf_backend_can_gc_sections 1
#define elf_backend_rela_normal 1
#define elf_backend_check_relocs mn10300_elf_check_relocs
mn10300_elf_get_relocated_section_contents
#define bfd_elf32_bfd_link_hash_table_create \
elf32_mn10300_link_hash_table_create
-#define bfd_elf32_bfd_link_hash_table_free \
- elf32_mn10300_link_hash_table_free
#ifndef elf_symbol_leading_char
#define elf_symbol_leading_char '_'
_bfd_mn10300_elf_adjust_dynamic_symbol
#define elf_backend_size_dynamic_sections \
_bfd_mn10300_elf_size_dynamic_sections
-#define elf_backend_omit_section_dynsym \
- ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
+#define elf_backend_omit_section_dynsym _bfd_elf_omit_section_dynsym_all
#define elf_backend_finish_dynamic_symbol \
_bfd_mn10300_elf_finish_dynamic_symbol
#define elf_backend_finish_dynamic_sections \
#define elf_backend_plt_readonly 1
#define elf_backend_want_plt_sym 0
#define elf_backend_got_header_size 12
+#define elf_backend_dtrel_excludes_plt 1
#include "elf32-target.h"
projects / deliverable / binutils-gdb.git / blobdiff