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

# This shell script emits a C file. -*- C -*-
#   Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
#   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 "libbfd.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 (" %I\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 ("  %I\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 (_("%FError: 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
				(_("%P%E%F: Can't make .cranges section\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 ();

  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;

			BFD_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);

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