[deliverable/binutils-gdb.git] / ld / emultempl / sh64elf.em

# This shell script emits a C file. -*- C -*-
#   Copyright (C) 2000-2018 Free Software Foundation, Inc.
#
# 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 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# 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., 51 Franklin Street - Fifth Floor, Boston,
# MA 02110-1301, USA.
#

# This file is sourced from elf32.em, and defines extra sh64
# specific routines.
#

LDEMUL_AFTER_ALLOCATION=sh64_elf_${EMULATION_NAME}_after_allocation
LDEMUL_BEFORE_ALLOCATION=sh64_elf_${EMULATION_NAME}_before_allocation

fragment <<EOF

#include "libiberty.h"
#include "elf-bfd.h"
#include "elf/sh.h"
#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,
   discard it, but I don't find a simple way to discard it totally from
   the output.

   Putting it here instead of as a elf_backend_always_size_sections hook
   in elf32-sh64.c, means that we have access to linker command line
   options here, and we can access input sections in the order in which
   they will be linked.  */

static void
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 (link_info.output_bfd,
				     SH64_CRANGES_SECTION_NAME);

  if (cranges != NULL)
    {
      if (RELAXATION_ENABLED)
	{
	  /* FIXME: Look through incoming sections with .cranges
	     descriptors, build up some kind of descriptors that the
	     relaxing function will pick up and adjust, or perhaps make it
	     find and adjust an associated .cranges descriptor.  We could
	     also look through incoming relocs and kill the ones marking
	     relaxation areas, but that wouldn't be TRT.  */
	  einfo
	    (_("%P: sorry, turning off relaxing: .cranges section in input\n"));
	  einfo (_(" A .cranges section is present in:\n"));

	  {
	    LANG_FOR_EACH_INPUT_STATEMENT (f)
	      {
		asection *input_cranges
		  = bfd_get_section_by_name (f->the_bfd,
					     SH64_CRANGES_SECTION_NAME);
		if (input_cranges != NULL)
		  einfo (" %pI\n", f);
	      }
	  }

	  DISABLE_RELAXATION;
	}

      /* We wouldn't need to do anything when there's already a .cranges
	 section (and have a return here), except that we need to set the
	 section flags right for output sections that *don't* need a
	 .cranges section.  */
    }

  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)
		{
		  if (elf_section_data (isec)->this_hdr.sh_flags
		      & (SHF_SH5_ISA32 | SHF_SH5_ISA32_MIXED))
		    {
		      einfo (_("%P: sorry, turning off relaxing: SHmedia sections present\n"));
		      einfo ("  %pI\n", f);
		      DISABLE_RELAXATION;
		      goto done_scanning_shmedia_sections;
		    }
		}
	    }
	}
    }
 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 = link_info.output_bfd->sections;
       osec != NULL;
       osec = osec->next)
    {
      struct sh64_section_data *sh64_sec_data;
      bfd_vma oflags_isa = 0;
      bfd_vma iflags_isa = 0;

      if (bfd_get_flavour (link_info.output_bfd) != bfd_target_elf_flavour)
	einfo (_("%F%P: error: non-ELF output formats are not supported by this target's linker\n"));

      sh64_sec_data = sh64_elf_section_data (osec)->sh64_info;

      /* Omit excluded or garbage-collected sections.  */
      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_info = sh64_sec_data;
	}

      /* First find an input section so we have flags to compare with; the
	 flags in the output section are not valid.  */
      {
	LANG_FOR_EACH_INPUT_STATEMENT (f)
	  {
	    asection *isec;

	    for (isec = f->the_bfd->sections;
		 isec != NULL;
		 isec = isec->next)
	      {
		if (isec->output_section == osec
		    && isec->size != 0
		    && (bfd_get_section_flags (isec->owner, isec)
			& SEC_EXCLUDE) == 0)
		  {
		    oflags_isa
		      = (elf_section_data (isec)->this_hdr.sh_flags
			 & (SHF_SH5_ISA32 | SHF_SH5_ISA32_MIXED));
		    goto break_1;
		  }
	      }
	  }
      }

    break_1:

      /* Check that all input sections have the same contents-type flags
	 as the first input section.  */
      {
	LANG_FOR_EACH_INPUT_STATEMENT (f)
	  {
	    asection *isec;

	    for (isec = f->the_bfd->sections;
		 isec != NULL;
		 isec = isec->next)
	      {
		if (isec->output_section == osec
		    && isec->size != 0
		    && (bfd_get_section_flags (isec->owner, isec)
			& SEC_EXCLUDE) == 0)
		  {
		    iflags_isa
		      = (elf_section_data (isec)->this_hdr.sh_flags
			 & (SHF_SH5_ISA32 | SHF_SH5_ISA32_MIXED));

		    /* If flags don't agree, we need a .cranges section.
		       Create it here if it did not exist through input
		       sections.  */
		    if (iflags_isa != oflags_isa)
		      {
			if (cranges == NULL)
			  {
			    /* This section will be *appended* to
			       sections, so the outer iteration will reach
			       it in due time and set
			       sh64_elf_section_data; no need to set it
			       specifically here.  */
			    cranges
			      = 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
				(_("%F%P: can't make .cranges section: %E\n"));
			  }

			/* We don't need to look at more input sections,
			   and we know this section will have mixed
			   contents.  */
			goto break_2;
		      }
		  }
	      }
	  }
      }

      /* If we got here, then all input sections in this output section
	 have the same contents flag.  Put that where we expect to see
	 contents flags.  We don't need to do this for sections that will
	 need additional, linker-generated .cranges entries.  */
      sh64_sec_data->contents_flags = iflags_isa;

    break_2:
      ;
    }
}

/* Size up and extend the .cranges section, merging generated entries.  */

static void
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 ();

  /* Needed, since we create link_orders here.  */
  lang_clear_os_map ();

  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
     be present in input.  */
  if (cranges == NULL)
    return;

  /* First, we set the ISA flags for each output section according to the
     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 = link_info.output_bfd->sections;
       osec != NULL;
       osec = osec->next)
    {
      bfd_vma oflags_isa = 0;
      bfd_boolean need_check_cranges = FALSE;

      /* Omit excluded or garbage-collected sections.  */
      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
	 flags in the output section are not valid.  */
      {
	LANG_FOR_EACH_INPUT_STATEMENT (f)
	  {
	    asection *isec;

	    for (isec = f->the_bfd->sections;
		 isec != NULL;
		 isec = isec->next)
	      {
		if (isec->output_section == osec
		    && isec->size != 0
		    && (bfd_get_section_flags (isec->owner, isec)
			& SEC_EXCLUDE) == 0)
		  {
		    oflags_isa
		      = (elf_section_data (isec)->this_hdr.sh_flags
			 & (SHF_SH5_ISA32 | SHF_SH5_ISA32_MIXED));
		    goto break_1;
		  }
	      }
	  }
      }

    break_1:

      /* Check that all input sections have the same contents-type flags
	 as the first input section.  */
      {
	LANG_FOR_EACH_INPUT_STATEMENT (f)
	  {
	    asection *isec;

	    for (isec = f->the_bfd->sections;
		 isec != NULL;
		 isec = isec->next)
	      {
		if (isec->output_section == osec
		    && isec->size != 0
		    && (bfd_get_section_flags (isec->owner, isec)
			& SEC_EXCLUDE) == 0)
		  {
		    bfd_vma iflags_isa
		      = (elf_section_data (isec)->this_hdr.sh_flags
			 & (SHF_SH5_ISA32 | SHF_SH5_ISA32_MIXED));

		    /* If flags don't agree, set the target-specific data
		       of the section to mark that this section needs to
		       be have .cranges section entries added.  Don't
		       bother setting ELF section flags in output section;
		       they will be cleared later and will have to be
		       re-initialized before the linked file is written.  */
		    if (iflags_isa != oflags_isa)
		      {
			oflags_isa = SHF_SH5_ISA32_MIXED;

			ASSERT (sh64_elf_section_data (osec)->sh64_info);

			sh64_elf_section_data (osec)->sh64_info->contents_flags
			  = SHF_SH5_ISA32_MIXED;
			need_check_cranges = TRUE;
			goto break_2;
		      }
		  }
	      }
	  }
      }

    break_2:

      /* If there were no new ranges for this output section, we don't
	 need to iterate over the input sections to check how many are
	 needed.  */
      if (! need_check_cranges)
	continue;

      /* If we found a section with differing contents type, we need more
	 ranges to mark the sections that are not mixed (and already have
	 .cranges descriptors).  Calculate the maximum number of new
	 entries here.  We may merge some of them, so that number is not
	 final; it can shrink.  */
      {
	LANG_FOR_EACH_INPUT_STATEMENT (f)
	  {
	    asection *isec;

	    for (isec = f->the_bfd->sections;
		 isec != NULL;
		 isec = isec->next)
	      {
		if (isec->output_section == osec
		    && isec->size != 0
		    && (bfd_get_section_flags (isec->owner, isec)
			& SEC_EXCLUDE) == 0
		    && ((elf_section_data (isec)->this_hdr.sh_flags
			 & (SHF_SH5_ISA32 | SHF_SH5_ISA32_MIXED))
			!= SHF_SH5_ISA32_MIXED))
		  new_cranges++;
	      }
	  }
      }
    }

  if (cranges->contents != NULL)
    free (cranges->contents);

  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 = xcalloc (cranges->size + cranges_growth, 1);
  bfd_set_section_flags (cranges->owner, cranges,
			 bfd_get_section_flags (cranges->owner, cranges)
			 | SEC_IN_MEMORY);

  /* If we don't need to grow the .cranges section beyond what was in the
     input sections, we have nothing more to do here.  We then only got
     here because there was a .cranges section coming from input.  Zero
     out the number of generated .cranges.  */
  if (new_cranges == 0)
    {
      sh64_elf_section_data (cranges)->sh64_info->cranges_growth = 0;
      return;
    }

  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 = link_info.output_bfd->sections;
       osec != NULL;
       osec = osec->next)
    {
      struct bfd_link_order *cr_addr_order = NULL;
      enum sh64_elf_cr_type last_cr_type = CRT_NONE;
      bfd_vma last_cr_size = 0;
      bfd_vma continuation_vma = 0;

      /* Omit excluded or garbage-collected sections, and output sections
	 which were not marked as needing further processing.  */
      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;

      {
	LANG_FOR_EACH_INPUT_STATEMENT (f)
	  {
	    asection *isec;

	    for (isec = f->the_bfd->sections;
		 isec != NULL;
		 isec = isec->next)
	      {
		/* Allow only sections that have (at least initially) a
		   non-zero size, and are not excluded, and are not marked
		   as containing mixed data, thus already having .cranges
		   entries.  */
		if (isec->output_section == osec
		    && isec->size != 0
		    && (bfd_get_section_flags (isec->owner, isec)
			& SEC_EXCLUDE) == 0
		    && ((elf_section_data (isec)->this_hdr.sh_flags
			 & (SHF_SH5_ISA32 | SHF_SH5_ISA32_MIXED))
			!= SHF_SH5_ISA32_MIXED))
		  {
		    enum sh64_elf_cr_type cr_type;
		    bfd_vma cr_size;
		    bfd_vma isa_flags
		      = (elf_section_data (isec)->this_hdr.sh_flags
			 & (SHF_SH5_ISA32 | SHF_SH5_ISA32_MIXED));

		    if (isa_flags == SHF_SH5_ISA32)
		      cr_type = CRT_SH5_ISA32;
		    else if ((bfd_get_section_flags (isec->owner, isec)
			      & SEC_CODE) == 0)
		      cr_type = CRT_DATA;
		    else
		      cr_type = CRT_SH5_ISA16;

		    cr_size = isec->size;

		    /* Sections can be empty, like .text in a file that
		       only contains other sections.  Ranges shouldn't be
		       emitted for them.  This can presumably happen after
		       relaxing and is not be caught at the "raw size"
		       test above.  */
		    if (cr_size == 0)
		      continue;

		    /* See if this is a continuation of the previous range
		       for the same output section.  If so, just change
		       the size of the last range and continue.  */
		    if (cr_type == last_cr_type
			&& (continuation_vma
			    == osec->vma + isec->output_offset))
		      {
			last_cr_size += cr_size;
			bfd_put_32 (link_info.output_bfd, last_cr_size,
				    crangesp - SH64_CRANGE_SIZE
				    + SH64_CRANGE_CR_SIZE_OFFSET);

			continuation_vma += cr_size;
			continue;
		      }

		    /* If we emit relocatable contents, we need a
		       relocation for the start address.  */
		    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 (link_info.output_bfd, cranges);

			if (cr_addr_order == NULL)
			  {
			    einfo (_("%F%P: bfd_new_link_order failed\n"));
			    return;
			  }

			cr_addr_order->type = bfd_section_reloc_link_order;
			cr_addr_order->offset
			  = (cranges->output_offset
			     + crangesp + SH64_CRANGE_CR_ADDR_OFFSET
			     - cranges->contents);
			cr_addr_order->size = 4;
			cr_addr_order->u.reloc.p
			  = 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;

			/* Since SH, unlike normal RELA-targets, uses a
			   "partial inplace" REL-like relocation for this,
			   we put the addend in the contents and specify 0
			   for the reloc.  */
			bfd_put_32 (link_info.output_bfd, isec->output_offset,
				    crangesp + SH64_CRANGE_CR_ADDR_OFFSET);
			cr_addr_order->u.reloc.p->addend = 0;
		      }
		    else
		      bfd_put_32 (link_info.output_bfd,
				  osec->vma + isec->output_offset,
				  crangesp + SH64_CRANGE_CR_ADDR_OFFSET);

		    /* If we could make a reloc for cr_size we would do
		       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 (link_info.output_bfd, cr_size,
				crangesp + SH64_CRANGE_CR_SIZE_OFFSET);

		    bfd_put_16 (link_info.output_bfd, cr_type,
				crangesp + SH64_CRANGE_CR_TYPE_OFFSET);

		    last_cr_type = cr_type;
		    last_cr_size = cr_size;
		    continuation_vma
		      = osec->vma + isec->output_offset + cr_size;
		    crangesp += SH64_CRANGE_SIZE;
		  }
	      }
	  }
      }
    }

  /* The .cranges section will have this size, no larger or smaller.
     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.  */

  sh64_elf_section_data (cranges)->sh64_info->cranges_growth
    = crangesp - cranges->contents - cranges->size;
  cranges->size = crangesp - cranges->contents;
  cranges->rawsize = cranges->size;
}
EOF
Commit	Line	Data
2d92cb7d	1	# This shell script emits a C file. -- C --
219d1afa	2	# Copyright (C) 2000-2018 Free Software Foundation, Inc.
2d92cb7d	3	#
f96b4a7b	4	# This file is part of the GNU Binutils.
2d92cb7d AO	5	#
	6	# This program is free software; you can redistribute it and/or modify
	7	# it under the terms of the GNU General Public License as published by
f96b4a7b	8	# the Free Software Foundation; either version 3 of the License, or
2d92cb7d AO	9	# (at your option) any later version.
	10	#
	11	# This program is distributed in the hope that it will be useful,
	12	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	# GNU General Public License for more details.
	15	#
	16	# You should have received a copy of the GNU General Public License
	17	# along with this program; if not, write to the Free Software
f96b4a7b NC	18	# Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
f96b4a7b NC	19	# MA 02110-1301, USA.
2d92cb7d AO	20	#
	21
	22	# This file is sourced from elf32.em, and defines extra sh64
	23	# specific routines.
	24	#
	25
	26	LDEMUL_AFTER_ALLOCATION=sh64_elf_${EMULATION_NAME}_after_allocation
	27	LDEMUL_BEFORE_ALLOCATION=sh64_elf_${EMULATION_NAME}_before_allocation
	28
92b93329	29	fragment <<EOF
2d92cb7d AO	30
2d92cb7d AO	31	#include "libiberty.h"
2d92cb7d AO	32	#include "elf-bfd.h"
2d92cb7d AO	33	#include "elf/sh.h"
f0abc2a1	34	#include "elf32-sh64.h"
2d92cb7d	35
2d92cb7d AO	36	/* Check if we need a .cranges section and create it if it's not in any
	37	input file. It might seem better to always create it and if unneeded,
	38	discard it, but I don't find a simple way to discard it totally from
	39	the output.
	40
	41	Putting it here instead of as a elf_backend_always_size_sections hook
	42	in elf32-sh64.c, means that we have access to linker command line
	43	options here, and we can access input sections in the order in which
	44	they will be linked. */
	45
	46	static void
0c7a8e5a	47	sh64_elf_${EMULATION_NAME}_before_allocation (void)
2d92cb7d AO	48	{
	49	asection *cranges;
	50	asection *osec;
	51
	52	/* Call main function; we're just extending it. */
	53	gld${EMULATION_NAME}_before_allocation ();
	54
f13a99db AM	55	cranges = bfd_get_section_by_name (link_info.output_bfd,
f13a99db AM	56	SH64_CRANGES_SECTION_NAME);
2d92cb7d AO	57
	58	if (cranges != NULL)
	59	{
28d5f677	60	if (RELAXATION_ENABLED)
2d92cb7d AO	61	{
	62	/* FIXME: Look through incoming sections with .cranges
	63	descriptors, build up some kind of descriptors that the
	64	relaxing function will pick up and adjust, or perhaps make it
	65	find and adjust an associated .cranges descriptor. We could
	66	also look through incoming relocs and kill the ones marking
	67	relaxation areas, but that wouldn't be TRT. */
	68	einfo
df5f2391	69	(_("%P: sorry, turning off relaxing: .cranges section in input\n"));
2d92cb7d AO	70	einfo (_(" A .cranges section is present in:\n"));
	71
	72	{
	73	LANG_FOR_EACH_INPUT_STATEMENT (f)
	74	{
	75	asection *input_cranges
	76	= bfd_get_section_by_name (f->the_bfd,
	77	SH64_CRANGES_SECTION_NAME);
	78	if (input_cranges != NULL)
c1c8c1ef	79	einfo (" %pI\n", f);
2d92cb7d AO	80	}
	81	}
	82
28d5f677	83	DISABLE_RELAXATION;
2d92cb7d AO	84	}
	85
	86	/* We wouldn't need to do anything when there's already a .cranges
	87	section (and have a return here), except that we need to set the
	88	section flags right for output sections that don't need a
	89	.cranges section. */
	90	}
	91
28d5f677	92	if (RELAXATION_ENABLED)
2d92cb7d AO	93	{
	94	LANG_FOR_EACH_INPUT_STATEMENT (f)
	95	{
	96	if (bfd_get_flavour (f->the_bfd) == bfd_target_elf_flavour)
	97	{
	98	asection *isec;
28d5f677	99
2d92cb7d AO	100	for (isec = f->the_bfd->sections;
	101	isec != NULL;
	102	isec = isec->next)
	103	{
	104	if (elf_section_data (isec)->this_hdr.sh_flags
	105	& (SHF_SH5_ISA32 \| SHF_SH5_ISA32_MIXED))
	106	{
df5f2391	107	einfo (_("%P: sorry, turning off relaxing: SHmedia sections present\n"));
c1c8c1ef	108	einfo (" %pI\n", f);
28d5f677	109	DISABLE_RELAXATION;
2d92cb7d AO	110	goto done_scanning_shmedia_sections;
	111	}
	112	}
	113	}
	114	}
	115	}
	116	done_scanning_shmedia_sections:
	117
	118	/* For each non-empty input section in each output section, check if it
	119	has the same SH64-specific flags. If some input section differs, we
	120	need a .cranges section. */
f13a99db	121	for (osec = link_info.output_bfd->sections;
2d92cb7d AO	122	osec != NULL;
	123	osec = osec->next)
	124	{
	125	struct sh64_section_data *sh64_sec_data;
	126	bfd_vma oflags_isa = 0;
	127	bfd_vma iflags_isa = 0;
	128
f13a99db	129	if (bfd_get_flavour (link_info.output_bfd) != bfd_target_elf_flavour)
df5f2391	130	einfo (_("%F%P: error: non-ELF output formats are not supported by this target's linker\n"));
2d92cb7d	131
f0abc2a1	132	sh64_sec_data = sh64_elf_section_data (osec)->sh64_info;
2d92cb7d AO	133
2d92cb7d AO	134	/* Omit excluded or garbage-collected sections. */
f13a99db	135	if (bfd_get_section_flags (link_info.output_bfd, osec) & SEC_EXCLUDE)
2d92cb7d AO	136	continue;
	137
	138	/* Make sure we have the target section data initialized. */
	139	if (sh64_sec_data == NULL)
	140	{
	141	sh64_sec_data = xcalloc (1, sizeof (struct sh64_section_data));
f0abc2a1	142	sh64_elf_section_data (osec)->sh64_info = sh64_sec_data;
2d92cb7d AO	143	}
	144
	145	/* First find an input section so we have flags to compare with; the
	146	flags in the output section are not valid. */
	147	{
	148	LANG_FOR_EACH_INPUT_STATEMENT (f)
	149	{
	150	asection *isec;
	151
	152	for (isec = f->the_bfd->sections;
	153	isec != NULL;
	154	isec = isec->next)
	155	{
	156	if (isec->output_section == osec
eea6121a	157	&& isec->size != 0
2d92cb7d AO	158	&& (bfd_get_section_flags (isec->owner, isec)
	159	& SEC_EXCLUDE) == 0)
	160	{
	161	oflags_isa
	162	= (elf_section_data (isec)->this_hdr.sh_flags
	163	& (SHF_SH5_ISA32 \| SHF_SH5_ISA32_MIXED));
	164	goto break_1;
	165	}
	166	}
	167	}
	168	}
	169
	170	break_1:
	171
	172	/* Check that all input sections have the same contents-type flags
6c19b93b	173	as the first input section. */
2d92cb7d AO	174	{
	175	LANG_FOR_EACH_INPUT_STATEMENT (f)
	176	{
	177	asection *isec;
	178
	179	for (isec = f->the_bfd->sections;
	180	isec != NULL;
	181	isec = isec->next)
	182	{
	183	if (isec->output_section == osec
eea6121a	184	&& isec->size != 0
2d92cb7d AO	185	&& (bfd_get_section_flags (isec->owner, isec)
	186	& SEC_EXCLUDE) == 0)
	187	{
	188	iflags_isa
	189	= (elf_section_data (isec)->this_hdr.sh_flags
	190	& (SHF_SH5_ISA32 \| SHF_SH5_ISA32_MIXED));
	191
	192	/* If flags don't agree, we need a .cranges section.
	193	Create it here if it did not exist through input
	194	sections. */
	195	if (iflags_isa != oflags_isa)
	196	{
	197	if (cranges == NULL)
	198	{
	199	/* This section will be appended to
	200	sections, so the outer iteration will reach
	201	it in due time and set
	202	sh64_elf_section_data; no need to set it
	203	specifically here. */
	204	cranges
9795b468 AM	205	= bfd_make_section_with_flags (link_info.output_bfd,
	206	SH64_CRANGES_SECTION_NAME,
	207	SEC_LINKER_CREATED
	208	\| SEC_KEEP
	209	\| SEC_HAS_CONTENTS
	210	\| SEC_DEBUGGING);
	211	if (cranges == NULL)
2d92cb7d	212	einfo
df5f2391	213	(_("%F%P: can't make .cranges section: %E\n"));
2d92cb7d AO	214	}
	215
	216	/* We don't need to look at more input sections,
	217	and we know this section will have mixed
	218	contents. */
	219	goto break_2;
	220	}
	221	}
	222	}
	223	}
	224	}
	225
	226	/* If we got here, then all input sections in this output section
	227	have the same contents flag. Put that where we expect to see
	228	contents flags. We don't need to do this for sections that will
	229	need additional, linker-generated .cranges entries. */
	230	sh64_sec_data->contents_flags = iflags_isa;
	231
	232	break_2:
	233	;
	234	}
	235	}
	236
	237	/* Size up and extend the .cranges section, merging generated entries. */
	238
	239	static void
0c7a8e5a	240	sh64_elf_${EMULATION_NAME}_after_allocation (void)
2d92cb7d AO	241	{
	242	bfd_vma new_cranges = 0;
	243	bfd_vma cranges_growth = 0;
	244	asection *osec;
	245	bfd_byte *crangesp;
eaeb0a9d	246	asection *cranges;
2d92cb7d	247
eaeb0a9d	248	gld${EMULATION_NAME}_after_allocation ();
2d92cb7d	249
18cd5bce AM	250	/* Needed, since we create link_orders here. */
	251	lang_clear_os_map ();
	252
eaeb0a9d AM	253	cranges = bfd_get_section_by_name (link_info.output_bfd,
eaeb0a9d AM	254	SH64_CRANGES_SECTION_NAME);
2d92cb7d AO	255
	256	/* If there is no .cranges section, it is because it was seen earlier on
	257	that none was needed. Otherwise it must have been created then, or
	258	be present in input. */
	259	if (cranges == NULL)
	260	return;
	261
	262	/* First, we set the ISA flags for each output section according to the
	263	first non-discarded section. For each input section in osec, we
	264	check if it has the same flags. If it does not, we set flags to mark
	265	a mixed section (and exit the loop early). */
f13a99db	266	for (osec = link_info.output_bfd->sections;
2d92cb7d AO	267	osec != NULL;
	268	osec = osec->next)
	269	{
	270	bfd_vma oflags_isa = 0;
b34976b6	271	bfd_boolean need_check_cranges = FALSE;
2d92cb7d AO	272
2d92cb7d AO	273	/* Omit excluded or garbage-collected sections. */
f13a99db	274	if (bfd_get_section_flags (link_info.output_bfd, osec) & SEC_EXCLUDE)
2d92cb7d AO	275	continue;
	276
	277	/* First find an input section so we have flags to compare with; the
	278	flags in the output section are not valid. */
	279	{
	280	LANG_FOR_EACH_INPUT_STATEMENT (f)
	281	{
	282	asection *isec;
	283
	284	for (isec = f->the_bfd->sections;
	285	isec != NULL;
	286	isec = isec->next)
	287	{
	288	if (isec->output_section == osec
eea6121a	289	&& isec->size != 0
2d92cb7d AO	290	&& (bfd_get_section_flags (isec->owner, isec)
	291	& SEC_EXCLUDE) == 0)
	292	{
	293	oflags_isa
	294	= (elf_section_data (isec)->this_hdr.sh_flags
	295	& (SHF_SH5_ISA32 \| SHF_SH5_ISA32_MIXED));
	296	goto break_1;
	297	}
	298	}
	299	}
	300	}
	301
	302	break_1:
	303
	304	/* Check that all input sections have the same contents-type flags
6c19b93b	305	as the first input section. */
2d92cb7d AO	306	{
	307	LANG_FOR_EACH_INPUT_STATEMENT (f)
	308	{
	309	asection *isec;
	310
	311	for (isec = f->the_bfd->sections;
	312	isec != NULL;
	313	isec = isec->next)
	314	{
	315	if (isec->output_section == osec
eea6121a	316	&& isec->size != 0
2d92cb7d AO	317	&& (bfd_get_section_flags (isec->owner, isec)
	318	& SEC_EXCLUDE) == 0)
	319	{
	320	bfd_vma iflags_isa
	321	= (elf_section_data (isec)->this_hdr.sh_flags
	322	& (SHF_SH5_ISA32 \| SHF_SH5_ISA32_MIXED));
	323
	324	/* If flags don't agree, set the target-specific data
	325	of the section to mark that this section needs to
	326	be have .cranges section entries added. Don't
	327	bother setting ELF section flags in output section;
	328	they will be cleared later and will have to be
	329	re-initialized before the linked file is written. */
	330	if (iflags_isa != oflags_isa)
	331	{
	332	oflags_isa = SHF_SH5_ISA32_MIXED;
	333
76e7a751	334	ASSERT (sh64_elf_section_data (osec)->sh64_info);
2d92cb7d	335
f0abc2a1	336	sh64_elf_section_data (osec)->sh64_info->contents_flags
2d92cb7d	337	= SHF_SH5_ISA32_MIXED;
b34976b6	338	need_check_cranges = TRUE;
2d92cb7d AO	339	goto break_2;
	340	}
	341	}
	342	}
	343	}
	344	}
	345
	346	break_2:
	347
	348	/* If there were no new ranges for this output section, we don't
	349	need to iterate over the input sections to check how many are
	350	needed. */
	351	if (! need_check_cranges)
	352	continue;
	353
	354	/* If we found a section with differing contents type, we need more
	355	ranges to mark the sections that are not mixed (and already have
	356	.cranges descriptors). Calculate the maximum number of new
	357	entries here. We may merge some of them, so that number is not
	358	final; it can shrink. */
	359	{
	360	LANG_FOR_EACH_INPUT_STATEMENT (f)
	361	{
	362	asection *isec;
	363
	364	for (isec = f->the_bfd->sections;
	365	isec != NULL;
	366	isec = isec->next)
	367	{
	368	if (isec->output_section == osec
eea6121a	369	&& isec->size != 0
2d92cb7d AO	370	&& (bfd_get_section_flags (isec->owner, isec)
	371	& SEC_EXCLUDE) == 0
	372	&& ((elf_section_data (isec)->this_hdr.sh_flags
	373	& (SHF_SH5_ISA32 \| SHF_SH5_ISA32_MIXED))
	374	!= SHF_SH5_ISA32_MIXED))
	375	new_cranges++;
	376	}
	377	}
	378	}
	379	}
	380
fb319d8d JR	381	if (cranges->contents != NULL)
	382	free (cranges->contents);
	383
76e7a751	384	ASSERT (sh64_elf_section_data (cranges)->sh64_info != NULL);
2d92cb7d AO	385
	386	/* Make sure we have .cranges in memory even if there were only
	387	assembler-generated .cranges. */
	388	cranges_growth = new_cranges * SH64_CRANGE_SIZE;
eea6121a	389	cranges->contents = xcalloc (cranges->size + cranges_growth, 1);
2d92cb7d AO	390	bfd_set_section_flags (cranges->owner, cranges,
	391	bfd_get_section_flags (cranges->owner, cranges)
	392	\| SEC_IN_MEMORY);
	393
	394	/* If we don't need to grow the .cranges section beyond what was in the
	395	input sections, we have nothing more to do here. We then only got
	396	here because there was a .cranges section coming from input. Zero
	397	out the number of generated .cranges. */
	398	if (new_cranges == 0)
	399	{
f0abc2a1	400	sh64_elf_section_data (cranges)->sh64_info->cranges_growth = 0;
2d92cb7d AO	401	return;
	402	}
	403
eea6121a	404	crangesp = cranges->contents + cranges->size;
2d92cb7d AO	405
	406	/* Now pass over the sections again, and make reloc orders for the new
	407	.cranges entries. Constants are set as we go. */
f13a99db	408	for (osec = link_info.output_bfd->sections;
2d92cb7d AO	409	osec != NULL;
	410	osec = osec->next)
	411	{
	412	struct bfd_link_order *cr_addr_order = NULL;
	413	enum sh64_elf_cr_type last_cr_type = CRT_NONE;
	414	bfd_vma last_cr_size = 0;
	415	bfd_vma continuation_vma = 0;
	416
	417	/* Omit excluded or garbage-collected sections, and output sections
	418	which were not marked as needing further processing. */
f13a99db	419	if ((bfd_get_section_flags (link_info.output_bfd, osec) & SEC_EXCLUDE) != 0
f0abc2a1	420	\|\| (sh64_elf_section_data (osec)->sh64_info->contents_flags
2d92cb7d AO	421	!= SHF_SH5_ISA32_MIXED))
	422	continue;
	423
	424	{
	425	LANG_FOR_EACH_INPUT_STATEMENT (f)
	426	{
	427	asection *isec;
	428
	429	for (isec = f->the_bfd->sections;
	430	isec != NULL;
	431	isec = isec->next)
	432	{
	433	/* Allow only sections that have (at least initially) a
	434	non-zero size, and are not excluded, and are not marked
	435	as containing mixed data, thus already having .cranges
	436	entries. */
	437	if (isec->output_section == osec
eea6121a	438	&& isec->size != 0
2d92cb7d AO	439	&& (bfd_get_section_flags (isec->owner, isec)
	440	& SEC_EXCLUDE) == 0
	441	&& ((elf_section_data (isec)->this_hdr.sh_flags
	442	& (SHF_SH5_ISA32 \| SHF_SH5_ISA32_MIXED))
	443	!= SHF_SH5_ISA32_MIXED))
	444	{
	445	enum sh64_elf_cr_type cr_type;
	446	bfd_vma cr_size;
	447	bfd_vma isa_flags
	448	= (elf_section_data (isec)->this_hdr.sh_flags
	449	& (SHF_SH5_ISA32 \| SHF_SH5_ISA32_MIXED));
	450
	451	if (isa_flags == SHF_SH5_ISA32)
	452	cr_type = CRT_SH5_ISA32;
	453	else if ((bfd_get_section_flags (isec->owner, isec)
	454	& SEC_CODE) == 0)
	455	cr_type = CRT_DATA;
	456	else
	457	cr_type = CRT_SH5_ISA16;
	458
eea6121a	459	cr_size = isec->size;
2d92cb7d AO	460
	461	/* Sections can be empty, like .text in a file that
	462	only contains other sections. Ranges shouldn't be
	463	emitted for them. This can presumably happen after
	464	relaxing and is not be caught at the "raw size"
	465	test above. */
	466	if (cr_size == 0)
	467	continue;
	468
	469	/* See if this is a continuation of the previous range
	470	for the same output section. If so, just change
	471	the size of the last range and continue. */
	472	if (cr_type == last_cr_type
	473	&& (continuation_vma
	474	== osec->vma + isec->output_offset))
	475	{
	476	last_cr_size += cr_size;
f13a99db	477	bfd_put_32 (link_info.output_bfd, last_cr_size,
2d92cb7d AO	478	crangesp - SH64_CRANGE_SIZE
	479	+ SH64_CRANGE_CR_SIZE_OFFSET);
	480
	481	continuation_vma += cr_size;
	482	continue;
	483	}
	484
1049f94e	485	/* If we emit relocatable contents, we need a
2d92cb7d	486	relocation for the start address. */
0e1862bb L	487	if (bfd_link_relocatable (&link_info)
0e1862bb L	488	\|\| link_info.emitrelocations)
2d92cb7d AO	489	{
	490	/* FIXME: We could perhaps use lang_add_reloc and
	491	friends here, but I'm not really sure that
	492	would leave us free to do some optimizations
	493	later. */
	494	cr_addr_order
f13a99db	495	= bfd_new_link_order (link_info.output_bfd, cranges);
2d92cb7d AO	496
	497	if (cr_addr_order == NULL)
	498	{
df5f2391	499	einfo (_("%F%P: bfd_new_link_order failed\n"));
2d92cb7d AO	500	return;
	501	}
	502
	503	cr_addr_order->type = bfd_section_reloc_link_order;
	504	cr_addr_order->offset
	505	= (cranges->output_offset
	506	+ crangesp + SH64_CRANGE_CR_ADDR_OFFSET
	507	- cranges->contents);
	508	cr_addr_order->size = 4;
	509	cr_addr_order->u.reloc.p
0c7a8e5a	510	= xmalloc (sizeof (struct bfd_link_order_reloc));
2d92cb7d AO	511
	512	cr_addr_order->u.reloc.p->reloc = BFD_RELOC_32;
	513	cr_addr_order->u.reloc.p->u.section = osec;
	514
	515	/* Since SH, unlike normal RELA-targets, uses a
	516	"partial inplace" REL-like relocation for this,
	517	we put the addend in the contents and specify 0
	518	for the reloc. */
f13a99db	519	bfd_put_32 (link_info.output_bfd, isec->output_offset,
2d92cb7d AO	520	crangesp + SH64_CRANGE_CR_ADDR_OFFSET);
2d92cb7d AO	521	cr_addr_order->u.reloc.p->addend = 0;
2d92cb7d AO	522	}
2d92cb7d AO	523	else
f13a99db	524	bfd_put_32 (link_info.output_bfd,
2d92cb7d AO	525	osec->vma + isec->output_offset,
	526	crangesp + SH64_CRANGE_CR_ADDR_OFFSET);
	527
	528	/* If we could make a reloc for cr_size we would do
	529	it, but we would have to have a symbol for the size
	530	of the _input_ section and there's no way to
	531	generate that. */
f13a99db	532	bfd_put_32 (link_info.output_bfd, cr_size,
2d92cb7d AO	533	crangesp + SH64_CRANGE_CR_SIZE_OFFSET);
2d92cb7d AO	534
f13a99db	535	bfd_put_16 (link_info.output_bfd, cr_type,
2d92cb7d AO	536	crangesp + SH64_CRANGE_CR_TYPE_OFFSET);
	537
	538	last_cr_type = cr_type;
	539	last_cr_size = cr_size;
	540	continuation_vma
	541	= osec->vma + isec->output_offset + cr_size;
	542	crangesp += SH64_CRANGE_SIZE;
	543	}
	544	}
	545	}
	546	}
	547	}
	548
	549	/* The .cranges section will have this size, no larger or smaller.
1049f94e	550	Since relocs (if relocatable linking) will be emitted into the
2d92cb7d AO	551	"extended" size, we must set the raw size to the total. We have to
	552	keep track of the number of new .cranges entries.
	553
	554	Sorting before writing is done by sh64_elf_final_write_processing. */
	555
f0abc2a1	556	sh64_elf_section_data (cranges)->sh64_info->cranges_growth
eea6121a AM	557	= crangesp - cranges->contents - cranges->size;
eea6121a AM	558	cranges->size = crangesp - cranges->contents;
24dc748d	559	cranges->rawsize = cranges->size;
2d92cb7d	560	}
54801c2d NC	561	EOF
	562
	563