URL https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [ld/] [emultempl/] [sh64elf.em] - Blame information for rev 166

Go to most recent revision | Details | Compare with Previous | View Log


# 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 <
 
#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
 
 

Browse

Tools

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [ld/] [emultempl/] [sh64elf.em] - Blame information for rev 166

Line No.	Rev	Author	Line
1	145	khays	`# This shell script emits a C file. -- C --`
2			`# Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009`
3			`# Free Software Foundation, Inc.`
4			`#`
5			`# This file is part of the GNU Binutils.`
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`
9			`# the Free Software Foundation; either version 3 of the License, or`
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`
19			`# Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,`
20			`# MA 02110-1301, USA.`
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
30			`fragment <`
31
32			`#include "libiberty.h"`
33			`#include "libbfd.h"`
34			`#include "elf-bfd.h"`
35			`#include "elf/sh.h"`
36			`#include "elf32-sh64.h"`
37
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`
49			`sh64_elf_${EMULATION_NAME}_before_allocation (void)`
50			`{`
51			`asection *cranges;`
52			`asection *osec;`
53
54			`/* Call main function; we're just extending it. */`
55			`gld${EMULATION_NAME}_before_allocation ();`
56
57			`cranges = bfd_get_section_by_name (link_info.output_bfd,`
58			`SH64_CRANGES_SECTION_NAME);`
59
60			`if (cranges != NULL)`
61			`{`
62			`if (RELAXATION_ENABLED)`
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
85			`DISABLE_RELAXATION;`
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
94			`if (RELAXATION_ENABLED)`
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;`
101
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);`
111			`DISABLE_RELAXATION;`
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. */`
123			`for (osec = link_info.output_bfd->sections;`
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
131			`if (bfd_get_flavour (link_info.output_bfd) != bfd_target_elf_flavour)`
132			`einfo (_("%FError: non-ELF output formats are not supported by this target's linker.\n"));`
133
134			`sh64_sec_data = sh64_elf_section_data (osec)->sh64_info;`
135
136			`/* Omit excluded or garbage-collected sections. */`
137			`if (bfd_get_section_flags (link_info.output_bfd, osec) & SEC_EXCLUDE)`
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));`
144			`sh64_elf_section_data (osec)->sh64_info = sh64_sec_data;`
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`
159			`&& isec->size != 0`
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`
186			`&& isec->size != 0`
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`
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)`
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`
242			`sh64_elf_${EMULATION_NAME}_after_allocation (void)`
243			`{`
244			`bfd_vma new_cranges = 0;`
245			`bfd_vma cranges_growth = 0;`
246			`asection *osec;`
247			`bfd_byte *crangesp;`
248			`asection *cranges;`
249
250			`gld${EMULATION_NAME}_after_allocation ();`
251
252			`cranges = bfd_get_section_by_name (link_info.output_bfd,`
253			`SH64_CRANGES_SECTION_NAME);`
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). */`
265			`for (osec = link_info.output_bfd->sections;`
266			`osec != NULL;`
267			`osec = osec->next)`
268			`{`
269			`bfd_vma oflags_isa = 0;`
270			`bfd_boolean need_check_cranges = FALSE;`
271
272			`/* Omit excluded or garbage-collected sections. */`
273			`if (bfd_get_section_flags (link_info.output_bfd, osec) & SEC_EXCLUDE)`
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`
288			`&& isec->size != 0`
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`
315			`&& isec->size != 0`
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
333			`BFD_ASSERT (sh64_elf_section_data (osec)->sh64_info);`
334
335			`sh64_elf_section_data (osec)->sh64_info->contents_flags`
336			`= SHF_SH5_ISA32_MIXED;`
337			`need_check_cranges = TRUE;`
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`
368			`&& isec->size != 0`
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
380			`if (cranges->contents != NULL)`
381			`free (cranges->contents);`
382
383			`BFD_ASSERT (sh64_elf_section_data (cranges)->sh64_info != NULL);`
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;`
388			`cranges->contents = xcalloc (cranges->size + cranges_growth, 1);`
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			`{`
399			`sh64_elf_section_data (cranges)->sh64_info->cranges_growth = 0;`
400			`return;`
401			`}`
402
403			`crangesp = cranges->contents + cranges->size;`
404
405			`/* Now pass over the sections again, and make reloc orders for the new`
406			`.cranges entries. Constants are set as we go. */`
407			`for (osec = link_info.output_bfd->sections;`
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. */`
418			`if ((bfd_get_section_flags (link_info.output_bfd, osec) & SEC_EXCLUDE) != 0`
419			`\|\| (sh64_elf_section_data (osec)->sh64_info->contents_flags`
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`
437			`&& isec->size != 0`
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
458			`cr_size = isec->size;`
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;`
476			`bfd_put_32 (link_info.output_bfd, last_cr_size,`
477			`crangesp - SH64_CRANGE_SIZE`
478			`+ SH64_CRANGE_CR_SIZE_OFFSET);`
479
480			`continuation_vma += cr_size;`
481			`continue;`
482			`}`
483
484			`/* If we emit relocatable contents, we need a`
485			`relocation for the start address. */`
486			`if (link_info.relocatable \|\| link_info.emitrelocations)`
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`
493			`= bfd_new_link_order (link_info.output_bfd, cranges);`
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`
508			`= xmalloc (sizeof (struct bfd_link_order_reloc));`
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. */`
517			`bfd_put_32 (link_info.output_bfd, isec->output_offset,`
518			`crangesp + SH64_CRANGE_CR_ADDR_OFFSET);`
519			`cr_addr_order->u.reloc.p->addend = 0;`
520			`}`
521			`else`
522			`bfd_put_32 (link_info.output_bfd,`
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. */`
530			`bfd_put_32 (link_info.output_bfd, cr_size,`
531			`crangesp + SH64_CRANGE_CR_SIZE_OFFSET);`
532
533			`bfd_put_16 (link_info.output_bfd, cr_type,`
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.`
548			`Since relocs (if relocatable linking) will be emitted into the`
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
554			`sh64_elf_section_data (cranges)->sh64_info->cranges_growth`
555			`= crangesp - cranges->contents - cranges->size;`
556			`cranges->size = crangesp - cranges->contents;`
557			`cranges->rawsize = cranges->size;`
558			`}`
559			`EOF`
560
561