ld/emultempl/cskyelf.em

   1 # This shell script emits a C file. -*- C -*-
   2 #   Copyright (C) 2013-2024 Free Software Foundation, Inc.
   3 #
   4 # This file is part of GNU Binutils.
   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
   8 # the Free Software Foundation; either version 3 of the License, or
   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
  18 # Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  19 # MA 02110-1301, USA.
  20
  21 # This file is sourced from elf.em, and defines extra C-SKY ELF
  22 # specific routines.
  23 #
  24 fragment <<EOF
  25
  26 #include "ldctor.h"
  27 #include "elf/csky.h"
  28 #include "elf32-csky.h"
  29
  30 /* To use branch stub or not.  */
  31 extern bool use_branch_stub;
  32
  33 /* Fake input file for stubs.  */
  34 static lang_input_statement_type *stub_file;
  35
  36 /* Whether we need to call gldcsky_layout_sections_again.  */
  37 static int need_laying_out = 0;
  38
  39 /* Maximum size of a group of input sections that can be handled by
  40    one stub section.  A value of +/-1 indicates the bfd back-end
  41    should use a suitable default size.  */
  42 static bfd_signed_vma group_size = 1;
  43
  44 struct hook_stub_info
  45 {
  46   lang_statement_list_type add;
  47   asection *input_section;
  48 };
  49
  50 /* Traverse the linker tree to find the spot where the stub goes.  */
  51 static bool
  52 hook_in_stub (struct hook_stub_info *info, lang_statement_union_type **lp)
  53 {
  54   lang_statement_union_type *l;
  55   bool ret;
  56
  57   for (l = *lp; l != NULL; lp = &l->header.next, l = *lp)
  58     switch (l->header.type)
  59       {
  60       case lang_constructors_statement_enum:
  61         ret = hook_in_stub (info, &constructor_list.head);
  62         if (ret)
  63           return ret;
  64         break;
  65
  66       case lang_output_section_statement_enum:
  67         ret = hook_in_stub (info,
  68                             &l->output_section_statement.children.head);
  69         if (ret)
  70           return ret;
  71         break;
  72
  73       case lang_wild_statement_enum:
  74         ret = hook_in_stub (info, &l->wild_statement.children.head);
  75         if (ret)
  76           return ret;
  77         break;
  78
  79       case lang_group_statement_enum:
  80         ret = hook_in_stub (info, &l->group_statement.children.head);
  81         if (ret)
  82           return ret;
  83         break;
  84
  85       case lang_input_section_enum:
  86         if (l->input_section.section == info->input_section)
  87           {
  88             /* We've found our section.  Insert the stub immediately
  89                after its associated input section.  */
  90             *(info->add.tail) = l->header.next;
  91             l->header.next = info->add.head;
  92             return true;
  93           }
  94         break;
  95
  96       case lang_data_statement_enum:
  97       case lang_reloc_statement_enum:
  98       case lang_object_symbols_statement_enum:
  99       case lang_output_statement_enum:
 100       case lang_target_statement_enum:
 101       case lang_input_statement_enum:
 102       case lang_assignment_statement_enum:
 103       case lang_padding_statement_enum:
 104       case lang_address_statement_enum:
 105       case lang_fill_statement_enum:
 106         break;
 107
 108       default:
 109         FAIL ();
 110         break;
 111       }
 112
 113   return false;
 114 }
 115 EOF
 116
 117 case ${target} in
 118     csky-*-linux-*)
 119 fragment <<EOF
 120
 121 static void
 122 csky_elf_before_parse (void)
 123 {
 124   use_branch_stub = false;
 125   gld${EMULATION_NAME}_before_parse ();
 126 }
 127 EOF
 128     ;;
 129 esac
 130
 131 fragment <<EOF
 132
 133 /* This is a convenient point to tell BFD about target specific flags.
 134    After the output has been created, but before inputs are read.  */
 135 static void
 136 csky_elf_create_output_section_statements (void)
 137 {
 138   if (!(bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour
 139         && elf_object_id (link_info.output_bfd) == CSKY_ELF_DATA))
 140     use_branch_stub = false;
 141
 142   /* If don't use branch stub, just do not emit stub_file.  */
 143   if (!use_branch_stub)
 144     return;
 145
 146   stub_file = lang_add_input_file ("linker stubs",
 147                                    lang_input_file_is_fake_enum, NULL);
 148   stub_file->the_bfd = bfd_create ("linker stubs", link_info.output_bfd);
 149   if (stub_file->the_bfd == NULL
 150       || !bfd_set_arch_mach (stub_file->the_bfd,
 151           bfd_get_arch (link_info.output_bfd),
 152           bfd_get_mach (link_info.output_bfd)))
 153     {
 154       einfo (_("%F%P: can not create BFD: %E\n"));
 155       return;
 156     }
 157
 158   stub_file->the_bfd->flags |= BFD_LINKER_CREATED;
 159   ldlang_add_file (stub_file);
 160 }
 161
 162 /* Call-back for elf32_csky_size_stubs.  */
 163
 164 /* Create a new stub section, and arrange for it to be linked
 165    immediately after INPUT_SECTION.  */
 166 static asection *
 167 elf32_csky_add_stub_section (const char *stub_sec_name,
 168                              asection *input_section)
 169 {
 170   asection *stub_sec;
 171   flagword flags;
 172   asection *output_section;
 173   const char *secname;
 174   lang_output_section_statement_type *os;
 175   struct hook_stub_info info;
 176
 177   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE
 178            | SEC_HAS_CONTENTS | SEC_RELOC | SEC_IN_MEMORY | SEC_KEEP);
 179   stub_sec = bfd_make_section_anyway_with_flags (stub_file->the_bfd,
 180                                                  stub_sec_name, flags);
 181   if (stub_sec == NULL)
 182     goto err_ret;
 183
 184   bfd_set_section_alignment (stub_sec, 3);
 185
 186   output_section = input_section->output_section;
 187   secname = bfd_section_name (output_section);
 188   os = lang_output_section_find (secname);
 189
 190   info.input_section = input_section;
 191   lang_list_init (&info.add);
 192   lang_add_section (&info.add, stub_sec, NULL, NULL, os);
 193
 194   if (info.add.head == NULL)
 195     goto err_ret;
 196
 197   if (hook_in_stub (&info, &os->children.head))
 198     return stub_sec;
 199
 200  err_ret:
 201   einfo (_("%X%P: can not make stub section: %E\n"));
 202   return NULL;
 203 }
 204
 205 /* Another call-back for elf_csky_size_stubs.  */
 206 static void
 207 gldcsky_layout_sections_again (void)
 208 {
 209   /* If we have changed sizes of the stub sections, then we need
 210      to recalculate all the section offsets.  This may mean we need to
 211      add even more stubs.  */
 212   ldelf_map_segments (true);
 213   need_laying_out = -1;
 214 }
 215
 216 static void
 217 build_section_lists (lang_statement_union_type *statement)
 218 {
 219   if (statement->header.type == lang_input_section_enum)
 220     {
 221       asection *i = statement->input_section.section;
 222
 223       if (i->sec_info_type != SEC_INFO_TYPE_JUST_SYMS
 224           && (i->flags & SEC_EXCLUDE) == 0
 225           && i->output_section != NULL
 226           && i->output_section->owner == link_info.output_bfd)
 227         elf32_csky_next_input_section (&link_info, i);
 228     }
 229 }
 230
 231 static void
 232 gld${EMULATION_NAME}_after_allocation (void)
 233 {
 234   /* bfd_elf32_discard_info just plays with debugging sections,
 235      ie. doesn't affect any code, so we can delay resizing the
 236      sections.  It's likely we'll resize everything in the process of
 237      adding stubs.  */
 238   if (bfd_elf_discard_info (link_info.output_bfd, &link_info))
 239     need_laying_out = 1;
 240
 241   /* If generating a relocatable output file, then we don't
 242      have to examine the relocs.  */
 243
 244   if (stub_file != NULL && !bfd_link_relocatable (&link_info))
 245     {
 246       int ret = elf32_csky_setup_section_lists (link_info.output_bfd,
 247                                                 &link_info);
 248
 249       if (ret < 0)
 250         {
 251           einfo (_("%X%P: could not compute sections lists for stub generation: %E\n"));
 252           return;
 253         }
 254       else if (ret != 0)
 255         {
 256           lang_for_each_statement (build_section_lists);
 257
 258           /* Call into the BFD backend to do the real work.  */
 259           if (! elf32_csky_size_stubs (link_info.output_bfd,
 260                                        stub_file->the_bfd,
 261                                        &link_info,
 262                                        group_size,
 263                                        &elf32_csky_add_stub_section,
 264                                        &gldcsky_layout_sections_again))
 265           {
 266             einfo (_("%X%P: cannot size stub section: %E\n"));
 267             return;
 268           }
 269         }
 270     }
 271
 272   if (need_laying_out != -1)
 273     ldelf_map_segments (need_laying_out);
 274 }
 275
 276 static void
 277 gld${EMULATION_NAME}_finish (void)
 278 {
 279   if (stub_file != NULL
 280       && !bfd_link_relocatable (&link_info)
 281       && stub_file->the_bfd->sections != NULL
 282       && !elf32_csky_build_stubs (&link_info))
 283     einfo (_("%X%P: cannot build stubs: %E\n"));
 284   finish_default ();
 285 }
 286
 287 EOF
 288
 289 # This code gets inserted into the generic elf32.sc linker script
 290 # and allows us to define our own command line switches.
 291 PARSE_AND_LIST_LONGOPTS='
 292   {"branch-stub",       no_argument,       NULL, OPTION_BRANCH_STUB},
 293   {"no-branch-stub",    no_argument,       NULL, OPTION_NO_BRANCH_STUB},
 294   {"stub-group-size",   required_argument, NULL, OPTION_STUBGROUP_SIZE},
 295 '
 296 PARSE_AND_LIST_OPTIONS='
 297   fprintf (file, _("  --[no-]branch-stub          "
 298                    "Disable/enable use of stubs to expand branch\n"
 299                    "                              "
 300                    "  instructions that cannot reach the target.\n"));
 301   fprintf (file, _("  --stub-group-size=N         "
 302                    "Maximum size of a group of input sections\n"
 303                    "                              "
 304                    "  handled by one stub section.\n"));
 305 '
 306
 307 PARSE_AND_LIST_ARGS_CASES='
 308   case OPTION_BRANCH_STUB:
 309     use_branch_stub = true;
 310     break;
 311   case OPTION_NO_BRANCH_STUB:
 312     use_branch_stub = false;
 313     break;
 314
 315   case OPTION_STUBGROUP_SIZE:
 316     {
 317       const char *end;
 318
 319       group_size = bfd_scan_vma (optarg, &end, 0);
 320       if (*end)
 321         einfo (_("%F%P: invalid number `%s'\''\n"), optarg);
 322     }
 323     break;
 324 '
 325
 326 case ${target} in
 327     csky-*-linux-*) LDEMUL_BEFORE_PARSE=csky_elf_before_parse ;;
 328 esac
 329 LDEMUL_AFTER_ALLOCATION=gld${EMULATION_NAME}_after_allocation
 330 LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS=csky_elf_create_output_section_statements
 331 LDEMUL_FINISH=gld${EMULATION_NAME}_finish