# This shell script emits a C file. -*- C -*-
-# Copyright (C) 2000, 2001 Free Software Foundation, Inc.
+# Copyright (C) 2000-2016 Free Software Foundation, Inc.
#
-# This file is part of GLD, the Gnu Linker.
+# This file is part of the GNU Binutils.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
+# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+# Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
+# MA 02110-1301, USA.
#
# This file is sourced from elf32.em, and defines extra sh64
LDEMUL_AFTER_ALLOCATION=sh64_elf_${EMULATION_NAME}_after_allocation
LDEMUL_BEFORE_ALLOCATION=sh64_elf_${EMULATION_NAME}_before_allocation
-cat >>e${EMULATION_NAME}.c <<EOF
+fragment <<EOF
#include "libiberty.h"
#include "libbfd.h"
#include "elf-bfd.h"
#include "elf/sh.h"
-
-static void sh64_elf_${EMULATION_NAME}_before_allocation PARAMS ((void));
-static void sh64_elf_${EMULATION_NAME}_after_allocation PARAMS ((void));
+#include "elf32-sh64.h"
/* Check if we need a .cranges section and create it if it's not in any
input file. It might seem better to always create it and if unneeded,
they will be linked. */
static void
-sh64_elf_${EMULATION_NAME}_before_allocation ()
+sh64_elf_${EMULATION_NAME}_before_allocation (void)
{
asection *cranges;
asection *osec;
/* Call main function; we're just extending it. */
gld${EMULATION_NAME}_before_allocation ();
- cranges = bfd_get_section_by_name (output_bfd, SH64_CRANGES_SECTION_NAME);
+ cranges = bfd_get_section_by_name (link_info.output_bfd,
+ SH64_CRANGES_SECTION_NAME);
if (cranges != NULL)
{
- if (command_line.relax)
+ if (RELAXATION_ENABLED)
{
/* FIXME: Look through incoming sections with .cranges
descriptors, build up some kind of descriptors that the
}
}
- command_line.relax = false;
+ DISABLE_RELAXATION;
}
/* We wouldn't need to do anything when there's already a .cranges
.cranges section. */
}
- if (command_line.relax)
+ if (RELAXATION_ENABLED)
{
LANG_FOR_EACH_INPUT_STATEMENT (f)
{
if (bfd_get_flavour (f->the_bfd) == bfd_target_elf_flavour)
{
asection *isec;
+
for (isec = f->the_bfd->sections;
isec != NULL;
isec = isec->next)
{
einfo (_("%P: Sorry, turning off relaxing: SHmedia sections present.\n"));
einfo (" %I\n", f);
- command_line.relax = false;
+ DISABLE_RELAXATION;
goto done_scanning_shmedia_sections;
}
}
/* For each non-empty input section in each output section, check if it
has the same SH64-specific flags. If some input section differs, we
need a .cranges section. */
- for (osec = output_bfd->sections;
+ for (osec = link_info.output_bfd->sections;
osec != NULL;
osec = osec->next)
{
bfd_vma oflags_isa = 0;
bfd_vma iflags_isa = 0;
- if (bfd_get_flavour (output_bfd) != bfd_target_elf_flavour)
+ if (bfd_get_flavour (link_info.output_bfd) != bfd_target_elf_flavour)
einfo (_("%FError: non-ELF output formats are not supported by this target's linker.\n"));
- sh64_sec_data = sh64_elf_section_data (osec);
+ sh64_sec_data = sh64_elf_section_data (osec)->sh64_info;
/* Omit excluded or garbage-collected sections. */
- if (bfd_get_section_flags (output_bfd, osec) & SEC_EXCLUDE)
+ if (bfd_get_section_flags (link_info.output_bfd, osec) & SEC_EXCLUDE)
continue;
/* Make sure we have the target section data initialized. */
if (sh64_sec_data == NULL)
{
sh64_sec_data = xcalloc (1, sizeof (struct sh64_section_data));
- sh64_elf_section_data (osec) = sh64_sec_data;
+ sh64_elf_section_data (osec)->sh64_info = sh64_sec_data;
}
/* First find an input section so we have flags to compare with; the
isec = isec->next)
{
if (isec->output_section == osec
- && isec->_raw_size != 0
+ && isec->size != 0
&& (bfd_get_section_flags (isec->owner, isec)
& SEC_EXCLUDE) == 0)
{
isec = isec->next)
{
if (isec->output_section == osec
- && isec->_raw_size != 0
+ && isec->size != 0
&& (bfd_get_section_flags (isec->owner, isec)
& SEC_EXCLUDE) == 0)
{
sh64_elf_section_data; no need to set it
specifically here. */
cranges
- = bfd_make_section (output_bfd,
- SH64_CRANGES_SECTION_NAME);
- if (cranges == NULL
- || (bfd_set_section_flags (output_bfd,
- cranges,
- SEC_LINKER_CREATED
- | SEC_KEEP
- | SEC_HAS_CONTENTS
- | SEC_DEBUGGING)
- == false))
+ = bfd_make_section_with_flags (link_info.output_bfd,
+ SH64_CRANGES_SECTION_NAME,
+ SEC_LINKER_CREATED
+ | SEC_KEEP
+ | SEC_HAS_CONTENTS
+ | SEC_DEBUGGING);
+ if (cranges == NULL)
einfo
(_("%P%E%F: Can't make .cranges section\n"));
}
/* Size up and extend the .cranges section, merging generated entries. */
static void
-sh64_elf_${EMULATION_NAME}_after_allocation ()
+sh64_elf_${EMULATION_NAME}_after_allocation (void)
{
bfd_vma new_cranges = 0;
bfd_vma cranges_growth = 0;
asection *osec;
bfd_byte *crangesp;
+ asection *cranges;
+
+ gld${EMULATION_NAME}_after_allocation ();
- asection *cranges
- = bfd_get_section_by_name (output_bfd, SH64_CRANGES_SECTION_NAME);
+ /* Needed, since we create link_orders here. */
+ lang_clear_os_map ();
- /* If this ever starts doing something, we will pick it up. */
- after_allocation_default ();
+ cranges = bfd_get_section_by_name (link_info.output_bfd,
+ SH64_CRANGES_SECTION_NAME);
/* If there is no .cranges section, it is because it was seen earlier on
that none was needed. Otherwise it must have been created then, or
first non-discarded section. For each input section in osec, we
check if it has the same flags. If it does not, we set flags to mark
a mixed section (and exit the loop early). */
- for (osec = output_bfd->sections;
+ for (osec = link_info.output_bfd->sections;
osec != NULL;
osec = osec->next)
{
bfd_vma oflags_isa = 0;
- boolean need_check_cranges = false;
+ bfd_boolean need_check_cranges = FALSE;
/* Omit excluded or garbage-collected sections. */
- if (bfd_get_section_flags (output_bfd, osec) & SEC_EXCLUDE)
+ if (bfd_get_section_flags (link_info.output_bfd, osec) & SEC_EXCLUDE)
continue;
/* First find an input section so we have flags to compare with; the
isec = isec->next)
{
if (isec->output_section == osec
- && isec->_raw_size != 0
+ && isec->size != 0
&& (bfd_get_section_flags (isec->owner, isec)
& SEC_EXCLUDE) == 0)
{
isec = isec->next)
{
if (isec->output_section == osec
- && isec->_raw_size != 0
+ && isec->size != 0
&& (bfd_get_section_flags (isec->owner, isec)
& SEC_EXCLUDE) == 0)
{
{
oflags_isa = SHF_SH5_ISA32_MIXED;
- BFD_ASSERT (sh64_elf_section_data (osec) != NULL);
+ BFD_ASSERT (sh64_elf_section_data (osec)->sh64_info);
- sh64_elf_section_data (osec)->contents_flags
+ sh64_elf_section_data (osec)->sh64_info->contents_flags
= SHF_SH5_ISA32_MIXED;
- need_check_cranges = true;
+ need_check_cranges = TRUE;
goto break_2;
}
}
isec = isec->next)
{
if (isec->output_section == osec
- && isec->_raw_size != 0
+ && isec->size != 0
&& (bfd_get_section_flags (isec->owner, isec)
& SEC_EXCLUDE) == 0
&& ((elf_section_data (isec)->this_hdr.sh_flags
}
}
- BFD_ASSERT (cranges->contents == NULL);
- BFD_ASSERT (sh64_elf_section_data (cranges) != NULL);
+ if (cranges->contents != NULL)
+ free (cranges->contents);
+
+ BFD_ASSERT (sh64_elf_section_data (cranges)->sh64_info != NULL);
/* Make sure we have .cranges in memory even if there were only
assembler-generated .cranges. */
cranges_growth = new_cranges * SH64_CRANGE_SIZE;
- cranges->contents
- = (bfd_byte *) xcalloc (cranges->_raw_size + cranges_growth, 1);
+ cranges->contents = xcalloc (cranges->size + cranges_growth, 1);
bfd_set_section_flags (cranges->owner, cranges,
bfd_get_section_flags (cranges->owner, cranges)
| SEC_IN_MEMORY);
out the number of generated .cranges. */
if (new_cranges == 0)
{
- sh64_elf_section_data (cranges)->cranges_growth = 0;
+ sh64_elf_section_data (cranges)->sh64_info->cranges_growth = 0;
return;
}
- crangesp = cranges->contents + cranges->_raw_size;
+ crangesp = cranges->contents + cranges->size;
/* Now pass over the sections again, and make reloc orders for the new
.cranges entries. Constants are set as we go. */
- for (osec = output_bfd->sections;
+ for (osec = link_info.output_bfd->sections;
osec != NULL;
osec = osec->next)
{
/* Omit excluded or garbage-collected sections, and output sections
which were not marked as needing further processing. */
- if ((bfd_get_section_flags (output_bfd, osec) & SEC_EXCLUDE) != 0
- || (sh64_elf_section_data (osec)->contents_flags
+ if ((bfd_get_section_flags (link_info.output_bfd, osec) & SEC_EXCLUDE) != 0
+ || (sh64_elf_section_data (osec)->sh64_info->contents_flags
!= SHF_SH5_ISA32_MIXED))
continue;
as containing mixed data, thus already having .cranges
entries. */
if (isec->output_section == osec
- && isec->_raw_size != 0
+ && isec->size != 0
&& (bfd_get_section_flags (isec->owner, isec)
& SEC_EXCLUDE) == 0
&& ((elf_section_data (isec)->this_hdr.sh_flags
else
cr_type = CRT_SH5_ISA16;
- cr_size
- = (isec->_cooked_size
- ? isec->_cooked_size : isec->_raw_size);
+ cr_size = isec->size;
/* Sections can be empty, like .text in a file that
only contains other sections. Ranges shouldn't be
== osec->vma + isec->output_offset))
{
last_cr_size += cr_size;
- bfd_put_32 (output_bfd, last_cr_size,
+ bfd_put_32 (link_info.output_bfd, last_cr_size,
crangesp - SH64_CRANGE_SIZE
+ SH64_CRANGE_CR_SIZE_OFFSET);
continue;
}
- /* If we emit relocateable contents, we need a
+ /* If we emit relocatable contents, we need a
relocation for the start address. */
- if (link_info.relocateable || link_info.emitrelocations)
+ if (bfd_link_relocatable (&link_info)
+ || link_info.emitrelocations)
{
/* FIXME: We could perhaps use lang_add_reloc and
friends here, but I'm not really sure that
would leave us free to do some optimizations
later. */
cr_addr_order
- = bfd_new_link_order (output_bfd, cranges);
+ = bfd_new_link_order (link_info.output_bfd, cranges);
if (cr_addr_order == NULL)
{
- cranges->contents);
cr_addr_order->size = 4;
cr_addr_order->u.reloc.p
- = ((struct bfd_link_order_reloc *)
- xmalloc (sizeof (struct bfd_link_order_reloc)));
+ = xmalloc (sizeof (struct bfd_link_order_reloc));
cr_addr_order->u.reloc.p->reloc = BFD_RELOC_32;
cr_addr_order->u.reloc.p->u.section = osec;
"partial inplace" REL-like relocation for this,
we put the addend in the contents and specify 0
for the reloc. */
- bfd_put_32 (output_bfd, isec->output_offset,
+ bfd_put_32 (link_info.output_bfd, isec->output_offset,
crangesp + SH64_CRANGE_CR_ADDR_OFFSET);
cr_addr_order->u.reloc.p->addend = 0;
-
- /* We must update the number of relocations here,
- since the elf linker does not take link orders
- into account when setting header sizes. The
- actual relocation orders are however executed
- correctly. */
- elf_section_data(cranges)->rel_count++;
}
else
- bfd_put_32 (output_bfd,
+ bfd_put_32 (link_info.output_bfd,
osec->vma + isec->output_offset,
crangesp + SH64_CRANGE_CR_ADDR_OFFSET);
it, but we would have to have a symbol for the size
of the _input_ section and there's no way to
generate that. */
- bfd_put_32 (output_bfd, cr_size,
+ bfd_put_32 (link_info.output_bfd, cr_size,
crangesp + SH64_CRANGE_CR_SIZE_OFFSET);
- bfd_put_16 (output_bfd, (bfd_vma) cr_type,
+ bfd_put_16 (link_info.output_bfd, cr_type,
crangesp + SH64_CRANGE_CR_TYPE_OFFSET);
last_cr_type = cr_type;
}
/* The .cranges section will have this size, no larger or smaller.
- Since relocs (if relocateable linking) will be emitted into the
+ Since relocs (if relocatable linking) will be emitted into the
"extended" size, we must set the raw size to the total. We have to
keep track of the number of new .cranges entries.
Sorting before writing is done by sh64_elf_final_write_processing. */
- cranges->_cooked_size = crangesp - cranges->contents;
- sh64_elf_section_data (cranges)->cranges_growth
- = cranges->_cooked_size - cranges->_raw_size;
- cranges->_raw_size = cranges->_cooked_size;
+ sh64_elf_section_data (cranges)->sh64_info->cranges_growth
+ = crangesp - cranges->contents - cranges->size;
+ cranges->size = crangesp - cranges->contents;
+ cranges->rawsize = cranges->size;
}
+EOF
+
+