ld/emultempl/cskyelf.em

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