/* 32-bit ELF support for S+core.
- Copyright 2009 Free Software Foundation, Inc.
+ Copyright (C) 2009-2017 Free Software Foundation, Inc.
Contributed by
Brain.lin (brain.lin@sunplusct.com)
Mei Ligang (ligang@sunnorth.com.cn)
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
MA 02110-1301, USA. */
-#include "bfd.h"
#include "sysdep.h"
+#include "bfd.h"
#include "libbfd.h"
#include "libiberty.h"
#include "elf-bfd.h"
#include "elf32-score.h"
-/* Score ELF linker hash table. */
-struct score_elf_link_hash_table
-{
- /* The main hash table. */
- struct elf_link_hash_table root;
-};
-
/* The SCORE ELF linker needs additional information for each symbol in
the global hash table. */
struct score_elf_link_hash_entry
/* Traverse a score ELF linker hash table. */
#define score_elf_link_hash_traverse(table, func, info) \
(elf_link_hash_traverse \
- (&(table)->root, \
+ ((table), \
(bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
(info)))
-/* Get the SCORE elf linker hash table from a link_info structure. */
-#define score_elf_hash_table(info) \
- ((struct score_elf_link_hash_table *) ((info)->hash))
-
/* This structure is used to hold .got entries while estimating got sizes. */
struct score_got_entry
{
/* No relocation. */
HOWTO (R_SCORE_NONE, /* type */
0, /* rightshift */
- 0, /* size (0 = byte, 1 = short, 2 = long) */
+ 3, /* size (0 = byte, 1 = short, 2 = long) */
0, /* bitsize */
FALSE, /* pc_relative */
0, /* bitpos */
{
struct score_elf_hash_sort_data *hsd = data;
- if (h->root.root.type == bfd_link_hash_warning)
- h = (struct score_elf_link_hash_entry *) h->root.root.u.i.link;
-
/* Symbols without dynamic symbol table entries aren't interesting at all. */
if (h->root.dynindx == -1)
return TRUE;
static asection *
score_elf_got_section (bfd *abfd, bfd_boolean maybe_excluded)
{
- asection *sgot = bfd_get_section_by_name (abfd, ".got");
+ asection *sgot = bfd_get_linker_section (abfd, ".got");
if (sgot == NULL || (! maybe_excluded && (sgot->flags & SEC_EXCLUDE) != 0))
return NULL;
too large offsets. */
- (g->next ? g->assigned_gotno : 0);
hsd.max_non_got_dynindx = max_local;
- score_elf_link_hash_traverse (((struct score_elf_link_hash_table *)
- elf_hash_table (info)),
- score_elf_sort_hash_table_f,
- &hsd);
+ score_elf_link_hash_traverse (elf_hash_table (info),
+ score_elf_sort_hash_table_f,
+ &hsd);
/* There should have been enough room in the symbol table to
accommodate both the GOT and non-GOT symbols. */
return TRUE;
}
-/* Create an entry in an score ELF linker hash table. */
-
-static struct bfd_hash_entry *
-score_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
- struct bfd_hash_table *table,
- const char *string)
-{
- struct score_elf_link_hash_entry *ret = (struct score_elf_link_hash_entry *) entry;
-
- /* Allocate the structure if it has not already been allocated by a subclass. */
- if (ret == NULL)
- ret = bfd_hash_allocate (table, sizeof (struct score_elf_link_hash_entry));
- if (ret == NULL)
- return (struct bfd_hash_entry *) ret;
-
- /* Call the allocation method of the superclass. */
- ret = ((struct score_elf_link_hash_entry *)
- _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
-
- if (ret != NULL)
- {
- ret->possibly_dynamic_relocs = 0;
- ret->readonly_reloc = FALSE;
- ret->no_fn_stub = FALSE;
- ret->forced_local = FALSE;
- }
-
- return (struct bfd_hash_entry *) ret;
-}
-
/* Returns the first relocation of type r_type found, beginning with
RELOCATION. RELEND is one-past-the-end of the relocation table. */
static const char dname[] = ".rel.dyn";
asection *sreloc;
- sreloc = bfd_get_section_by_name (dynobj, dname);
+ sreloc = bfd_get_linker_section (dynobj, dname);
if (sreloc == NULL && create_p)
{
- sreloc = bfd_make_section_with_flags (dynobj, dname,
- (SEC_ALLOC
- | SEC_LOAD
- | SEC_HAS_CONTENTS
- | SEC_IN_MEMORY
- | SEC_LINKER_CREATED
- | SEC_READONLY));
+ sreloc = bfd_make_section_anyway_with_flags (dynobj, dname,
+ (SEC_ALLOC
+ | SEC_LOAD
+ | SEC_HAS_CONTENTS
+ | SEC_IN_MEMORY
+ | SEC_LINKER_CREATED
+ | SEC_READONLY));
if (sreloc == NULL
|| ! bfd_set_section_alignment (dynobj, sreloc,
SCORE_ELF_LOG_FILE_ALIGN (dynobj)))
/* We have to use an alignment of 2**4 here because this is hardcoded
in the function stub generation and in the linker script. */
- s = bfd_make_section_with_flags (abfd, ".got", flags);
- if (s == NULL
+ s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
+ elf_hash_table (info)->sgot = s;
+ if (s == NULL
|| ! bfd_set_section_alignment (abfd, s, 4))
return FALSE;
h->non_elf = 0;
h->def_regular = 1;
h->type = STT_OBJECT;
+ elf_hash_table (info)->hgot = h;
- if (info->shared && ! bfd_elf_link_record_dynamic_symbol (info, h))
+ if (bfd_link_pic (info)
+ && ! bfd_elf_link_record_dynamic_symbol (info, h))
return FALSE;
amt = sizeof (struct score_got_info);
{
(*loc)->gotidx = -1;
/* We didn't allocate enough space in the GOT. */
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("not enough GOT space for local GOT entries"));
bfd_set_error (bfd_error_bad_value);
return NULL;
static bfd_vma
score_elf_global_got_index (bfd *abfd, struct elf_link_hash_entry *h)
{
- bfd_vma index;
+ bfd_vma got_index;
asection *sgot;
struct score_got_info *g;
long global_got_dynindx = 0;
indices into the GOT. That makes it easy to calculate the GOT
offset. */
BFD_ASSERT (h->dynindx >= global_got_dynindx);
- index = ((h->dynindx - global_got_dynindx + g->local_gotno) * SCORE_ELF_GOT_SIZE (abfd));
- BFD_ASSERT (index < sgot->size);
+ got_index = ((h->dynindx - global_got_dynindx + g->local_gotno) * SCORE_ELF_GOT_SIZE (abfd));
+ BFD_ASSERT (got_index < sgot->size);
- return index;
+ return got_index;
}
/* Returns the offset for the entry at the INDEXth position in the GOT. */
static bfd_vma
-score_elf_got_offset_from_index (bfd *dynobj, bfd *output_bfd,
- bfd *input_bfd ATTRIBUTE_UNUSED, bfd_vma index)
+score_elf_got_offset_from_index (bfd *dynobj,
+ bfd *output_bfd,
+ bfd *input_bfd ATTRIBUTE_UNUSED,
+ bfd_vma got_index)
{
asection *sgot;
bfd_vma gp;
- struct score_got_info *g;
- g = score_elf_got_info (dynobj, &sgot);
+ score_elf_got_info (dynobj, &sgot);
gp = _bfd_get_gp_value (output_bfd);
- return sgot->output_section->vma + sgot->output_offset + index - gp;
+ return sgot->output_section->vma + sgot->output_offset + got_index - gp;
}
/* Follow indirect and warning hash entries so that each got entry
bh = bfd_link_hash_lookup (info->hash, "_gp", 0, 0, 1);
if (bh != NULL && bh->type == bfd_link_hash_defined)
- elf_gp (output_bfd) = (bh->u.def.value
- + bh->u.def.section->output_section->vma
- + bh->u.def.section->output_offset);
- else if (info->relocatable)
+ {
+ elf_gp (output_bfd) = (bh->u.def.value
+ + bh->u.def.section->output_offset);
+ if (bh->u.def.section->output_section)
+ elf_gp (output_bfd) += bh->u.def.section->output_section->vma;
+ }
+ else if (bfd_link_relocatable (info))
{
bfd_vma lo = -1;
g = score_elf_global_got_index (elf_hash_table (info)->dynobj,
(struct elf_link_hash_entry *) h);
if ((! elf_hash_table(info)->dynamic_sections_created
- || (info->shared
+ || (bfd_link_pic (info)
&& (info->symbolic || h->root.dynindx == -1)
&& h->root.def_regular)))
{
case R_SCORE_ABS32:
case R_SCORE_REL32:
- if ((info->shared
+ if ((bfd_link_pic (info)
|| (elf_hash_table (info)->dynamic_sections_created
&& h != NULL
&& h->root.def_dynamic
&& !h->root.def_regular))
- && r_symndx != 0
+ && r_symndx != STN_UNDEF
&& (input_section->flags & SEC_ALLOC) != 0)
{
/* If we're creating a shared library, or this relocation is against a symbol
input_section))
return bfd_reloc_undefined;
}
- else if (r_symndx == 0)
- /* r_symndx will be zero only for relocs against symbols
+ else if (r_symndx == STN_UNDEF)
+ /* r_symndx will be STN_UNDEF (zero) only for relocs against symbols
from removed linkonce sections, or sections discarded by
a linker script. */
value = 0;
if ((offset & 0x1000000) != 0)
offset |= 0xfe000000;
value += offset;
- abs_value = abs (value - rel_addr);
+ abs_value = value - rel_addr;
if ((abs_value & 0xfe000000) != 0)
return bfd_reloc_overflow;
addend = (addend & ~howto->src_mask)
if ((offset & 0x800) != 0) /* Offset is negative. */
offset |= 0xfffff000;
value += offset;
- abs_value = abs (value - rel_addr);
+ abs_value = value - rel_addr;
if ((abs_value & 0xfffff000) != 0)
return bfd_reloc_overflow;
addend = (addend & ~howto->src_mask) | (value & howto->src_mask);
asection **local_sections)
{
Elf_Internal_Shdr *symtab_hdr;
- struct elf_link_hash_entry **sym_hashes;
Elf_Internal_Rela *rel;
Elf_Internal_Rela *relend;
const char *name;
if (elf_hash_table (info)->dynamic_sections_created)
{
bfd_size_type dynsecsymcount = 0;
- if (info->shared)
+ if (bfd_link_pic (info))
{
asection * p;
const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info;
- sym_hashes = elf_sym_hashes (input_bfd);
rel = relocs;
relend = relocs + input_section->reloc_count;
for (; rel < relend; rel++)
relocation = sec->output_section->vma + sec->output_offset;
name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
- if (!info->relocatable)
+ if (!bfd_link_relocatable (info))
{
if (ELF_ST_TYPE (sym->st_info) != STT_SECTION
|| (sec->flags & SEC_MERGE))
/* For global symbols we look up the symbol in the hash-table. */
h = ((struct score_elf_link_hash_entry *)
elf_sym_hashes (input_bfd) [r_symndx - extsymoff]);
+
+ if (info->wrap_hash != NULL
+ && (input_section->flags & SEC_DEBUGGING) != 0)
+ h = ((struct score_elf_link_hash_entry *)
+ unwrap_hash_lookup (info, input_bfd, &h->root.root));
+
/* Find the real hash-table entry for this symbol. */
while (h->root.root.type == bfd_link_hash_indirect
|| h->root.root.type == bfd_link_hash_warning)
/* If this is a dynamic link, we should have created a _DYNAMIC_LINK symbol
in s7_bfd_score_elf_create_dynamic_sections. Otherwise, we should define
the symbol with a value of 0. */
- BFD_ASSERT (! info->shared);
+ BFD_ASSERT (! bfd_link_pic (info));
BFD_ASSERT (bfd_get_section_by_name (output_bfd, ".dynamic") == NULL);
relocation = 0;
}
- else if (!info->relocatable)
+ else if (!bfd_link_relocatable (info))
{
- if (! ((*info->callbacks->undefined_symbol)
- (info, h->root.root.root.string, input_bfd,
- input_section, rel->r_offset,
- (info->unresolved_syms_in_objects == RM_GENERATE_ERROR)
- || ELF_ST_VISIBILITY (h->root.other))))
- return bfd_reloc_undefined;
+ (*info->callbacks->undefined_symbol)
+ (info, h->root.root.root.string, input_bfd,
+ input_section, rel->r_offset,
+ (info->unresolved_syms_in_objects == RM_GENERATE_ERROR)
+ || ELF_ST_VISIBILITY (h->root.other));
relocation = 0;
}
}
- 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))
{
/* This is a relocatable link. We don't have to change
anything, unless the reloc is against a section symbol,
if (r_type == R_SCORE_GOT15)
{
- const Elf_Internal_Rela *relend;
const Elf_Internal_Rela *lo16_rel;
const struct elf_backend_data *bed;
bfd_vma lo_addend = 0, lo_value = 0;
/* If the overflowing reloc was to an undefined symbol,
we have already printed one error message and there
is no point complaining again. */
- if (((!h) || (h->root.root.type != bfd_link_hash_undefined))
- && (!((*info->callbacks->reloc_overflow)
- (info, NULL, name, howto->name, (bfd_vma) 0,
- input_bfd, input_section, rel->r_offset))))
- return FALSE;
+ if (!h || h->root.root.type != bfd_link_hash_undefined)
+ (*info->callbacks->reloc_overflow)
+ (info, 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:
default:
msg = _("internal error: unknown error");
- /* fall through */
+ /* Fall through. */
common_error:
- if (!((*info->callbacks->warning)
- (info, msg, name, input_bfd, input_section, rel->r_offset)))
- return FALSE;
+ (*info->callbacks->warning) (info, msg, name, input_bfd,
+ input_section, rel->r_offset);
break;
}
}
asection *sreloc;
const struct elf_backend_data *bed;
- if (info->relocatable)
+ if (bfd_link_relocatable (info))
return TRUE;
dynobj = elf_hash_table (info)->dynobj;
}
else if (r_symndx >= extsymoff + NUM_SHDR_ENTRIES (symtab_hdr))
{
- (*_bfd_error_handler) (_("%s: Malformed reloc detected for section %s"), abfd, name);
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%s: Malformed reloc detected for section %s"), abfd, name);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
{
while (h->root.type == bfd_link_hash_indirect)
h = (struct elf_link_hash_entry *) h->root.u.i.link;
+
+ /* PR15323, ref flags aren't set for references in the
+ same object. */
+ h->root.non_ir_ref = 1;
}
}
break;
case R_SCORE_ABS32:
case R_SCORE_REL32:
- if (dynobj == NULL && (info->shared || h != NULL) && (sec->flags & SEC_ALLOC) != 0)
+ if (dynobj == NULL
+ && (bfd_link_pic (info) || h != NULL)
+ && (sec->flags & SEC_ALLOC) != 0)
elf_hash_table (info)->dynobj = dynobj = abfd;
break;
default:
case R_SCORE_CALL15:
if (h == NULL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
+ /* xgettext:c-format */
(_("%B: CALL15 reloc at 0x%lx not against global symbol"),
abfd, (unsigned long) rel->r_offset);
bfd_set_error (bfd_error_bad_value);
break;
case R_SCORE_ABS32:
case R_SCORE_REL32:
- if ((info->shared || h != NULL) && (sec->flags & SEC_ALLOC) != 0)
+ if ((bfd_link_pic (info) || h != NULL)
+ && (sec->flags & SEC_ALLOC) != 0)
{
if (sreloc == NULL)
{
return FALSE;
}
#define SCORE_READONLY_SECTION (SEC_ALLOC | SEC_LOAD | SEC_READONLY)
- if (info->shared)
+ if (bfd_link_pic (info))
{
/* When creating a shared object, we must copy these reloc types into
the output file as R_SCORE_REL32 relocs. We make room for this reloc
any R_SCORE_ABS32 or R_SCORE_REL32 relocs against it into the output
file. */
hscore = (struct score_elf_link_hash_entry *) h;
- if (!info->relocatable
+ if (!bfd_link_relocatable (info)
&& hscore->possibly_dynamic_relocs != 0
&& (h->root.type == bfd_link_hash_defweak || !h->def_regular))
{
if (!h->def_regular)
{
/* We need .stub section. */
- s = bfd_get_section_by_name (dynobj, SCORE_ELF_STUB_SECTION_NAME);
+ s = bfd_get_linker_section (dynobj, SCORE_ELF_STUB_SECTION_NAME);
BFD_ASSERT (s != NULL);
h->root.u.def.section = s;
/* Calculate the total loadable size of the output. That will give us the
maximum number of GOT_PAGE entries required. */
- for (sub = info->input_bfds; sub; sub = sub->link_next)
+ for (sub = info->input_bfds; sub; sub = sub->link.next)
{
asection *subsection;
if (elf_hash_table (info)->dynamic_sections_created)
{
/* Set the contents of the .interp section to the interpreter. */
- if (!info->shared)
+ if (!bfd_link_pic (info) && !info->nointerp)
{
- s = bfd_get_section_by_name (dynobj, ".interp");
+ s = bfd_get_linker_section (dynobj, ".interp");
BFD_ASSERT (s != NULL);
s->size = strlen (ELF_DYNAMIC_INTERPRETER) + 1;
s->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER;
| SEC_LINKER_CREATED | SEC_READONLY);
/* ABI requests the .dynamic section to be read only. */
- s = bfd_get_section_by_name (abfd, ".dynamic");
+ s = bfd_get_linker_section (abfd, ".dynamic");
if (s != NULL)
{
if (!bfd_set_section_flags (abfd, s, flags))
return FALSE;
/* Create .stub section. */
- if (bfd_get_section_by_name (abfd, SCORE_ELF_STUB_SECTION_NAME) == NULL)
+ if (bfd_get_linker_section (abfd, SCORE_ELF_STUB_SECTION_NAME) == NULL)
{
- s = bfd_make_section_with_flags (abfd, SCORE_ELF_STUB_SECTION_NAME,
- flags | SEC_CODE);
+ s = bfd_make_section_anyway_with_flags (abfd, SCORE_ELF_STUB_SECTION_NAME,
+ flags | SEC_CODE);
if (s == NULL
|| !bfd_set_section_alignment (abfd, s, 2))
return FALSE;
}
- if (!info->shared)
+ if (!bfd_link_pic (info))
{
const char *name;
/* This symbol has a stub. Set it up. */
BFD_ASSERT (h->dynindx != -1);
- s = bfd_get_section_by_name (dynobj, SCORE_ELF_STUB_SECTION_NAME);
+ s = bfd_get_linker_section (dynobj, SCORE_ELF_STUB_SECTION_NAME);
BFD_ASSERT (s != NULL);
/* FIXME: Can h->dynindex be more than 64K? */
/* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
name = h->root.root.string;
- if (strcmp (name, "_DYNAMIC") == 0 || strcmp (name, "_GLOBAL_OFFSET_TABLE_") == 0)
+ if (h == elf_hash_table (info)->hdynamic
+ || h == elf_hash_table (info)->hgot)
sym->st_shndx = SHN_ABS;
else if (strcmp (name, "_DYNAMIC_LINK") == 0)
{
dynobj = elf_hash_table (info)->dynobj;
- sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
+ sdyn = bfd_get_linker_section (dynobj, ".dynamic");
sgot = score_elf_got_section (dynobj, FALSE);
if (sgot == NULL)
switch (dyn.d_tag)
{
case DT_RELENT:
- s = score_elf_rel_dyn_section (dynobj, FALSE);
- BFD_ASSERT (s != NULL);
dyn.d_un.d_val = SCORE_ELF_REL_SIZE (dynobj);
break;
case DT_STRSZ:
/* Rewrite DT_STRSZ. */
- dyn.d_un.d_val = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
- break;
+ dyn.d_un.d_val
+ = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
+ break;
case DT_PLTGOT:
- name = ".got";
- s = bfd_get_section_by_name (output_bfd, name);
- BFD_ASSERT (s != NULL);
- dyn.d_un.d_ptr = s->vma;
+ s = elf_hash_table (info)->sgot;
+ dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
break;
case DT_SCORE_BASE_ADDRESS:
}
/* In case if we don't have global got symbols we default
to setting DT_SCORE_GOTSYM to the same value as
- DT_SCORE_SYMTABNO, so we just fall through. */
+ DT_SCORE_SYMTABNO. */
+ /* Fall through. */
case DT_SCORE_SYMTABNO:
name = ".dynsym";
elemsize = SCORE_ELF_SYM_SIZE (output_bfd);
- s = bfd_get_section_by_name (output_bfd, name);
- BFD_ASSERT (s != NULL);
-
+ s = bfd_get_linker_section (dynobj, name);
dyn.d_un.d_val = s->size / elemsize;
break;
case 272: /* Linux/Score elf_prstatus */
/* 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 + 24);
+ elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
/* pr_reg */
offset = 72;
}
/* Make a ".reg/999" section. */
- return _bfd_elfcore_make_pseudosection (abfd, ".reg", raw_size, note->descpos + offset);
+ return _bfd_elfcore_make_pseudosection (abfd, ".reg", raw_size,
+ note->descpos + offset);
}
bfd_boolean
case 128: /* Linux/Score elf_prpsinfo. */
/* pr_fname */
- elf_tdata (abfd)->core_program = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16);
+ elf_tdata (abfd)->core->program
+ = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16);
/* pr_psargs */
- elf_tdata (abfd)->core_command = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80);
+ elf_tdata (abfd)->core->command
+ = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80);
break;
}
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] == ' ')
return NULL;
}
-/* Create a score elf linker hash table. */
-
-struct bfd_link_hash_table *
-s7_elf32_score_link_hash_table_create (bfd *abfd)
-{
- struct score_elf_link_hash_table *ret;
- bfd_size_type amt = sizeof (struct score_elf_link_hash_table);
-
- ret = bfd_malloc (amt);
- if (ret == NULL)
- return NULL;
-
- if (!_bfd_elf_link_hash_table_init (&ret->root, abfd, score_elf_link_hash_newfunc,
- sizeof (struct score_elf_link_hash_entry)))
- {
- free (ret);
- return NULL;
- }
-
- return &ret->root.root;
-}
-
bfd_boolean
s7_elf32_score_print_private_bfd_data (bfd *abfd, void * ptr)
{
}
bfd_boolean
-s7_elf32_score_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
+s7_elf32_score_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
{
+ bfd *obfd = info->output_bfd;
flagword in_flags;
flagword out_flags;
- if (!_bfd_generic_verify_endian_match (ibfd, obfd))
+ if (!_bfd_generic_verify_endian_match (ibfd, info))
return FALSE;
in_flags = elf_elfheader (ibfd)->e_flags;
if (((in_flags & EF_SCORE_PIC) != 0) != ((out_flags & EF_SCORE_PIC) != 0))
{
- (*_bfd_error_handler) (_("%B: warning: linking PIC files with non-PIC files"), ibfd);
+ _bfd_error_handler (_("%B: warning: linking PIC files with non-PIC files"), ibfd);
}
/* Maybe dependency fix compatibility should be checked here. */