ld/emultempl/aarch64elf.em

   1 # This shell script emits a C file. -*- C -*-
   2 #   Copyright 2009-2012  Free Software Foundation, Inc.
   3 #   Contributed by ARM Ltd.
   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; see the file COPYING3. If not,
  19 # see <http://www.gnu.org/licenses/>.
  20 #
  21
  22 # This file is sourced from elf32.em, and defines extra aarch64-elf
  23 # specific routines.
  24 #
  25 fragment <<EOF
  26
  27 #include "ldctor.h"
  28 #include "elf/aarch64.h"
  29
  30 static int no_enum_size_warning = 0;
  31 static int no_wchar_size_warning = 0;
  32 static int pic_veneer = 0;
  33
  34 static void
  35 gld${EMULATION_NAME}_before_parse (void)
  36 {
  37 #ifndef TARGET_                 /* I.e., if not generic.  */
  38   ldfile_set_output_arch ("`echo ${ARCH}`", bfd_arch_unknown);
  39 #endif /* not TARGET_ */
  40   input_flags.dynamic = ${DYNAMIC_LINK-TRUE};
  41   config.has_shared = `if test -n "$GENERATE_SHLIB_SCRIPT" ; then echo TRUE ; else echo FALSE ; fi`;
  42   config.separate_code = `if test "x${SEPARATE_CODE}" = xyes ; then echo TRUE ; else echo FALSE ; fi`;
  43 }
  44
  45 static void
  46 aarch64_elf_before_allocation (void)
  47 {
  48   /* We should be able to set the size of the interworking stub section.  We
  49      can't do it until later if we have dynamic sections, though.  */
  50   if (! elf_hash_table (&link_info)->dynamic_sections_created)
  51     {
  52       /* Here we rummage through the found bfds to collect information.  */
  53       LANG_FOR_EACH_INPUT_STATEMENT (is)
  54         {
  55           /* Initialise mapping tables for code/data.  */
  56           bfd_elf64_aarch64_init_maps (is->the_bfd);
  57         }
  58     }
  59
  60   /* Call the standard elf routine.  */
  61   gld${EMULATION_NAME}_before_allocation ();
  62 }
  63
  64 /* Fake input file for stubs.  */
  65 static lang_input_statement_type *stub_file;
  66
  67 /* Whether we need to call gldarm_layout_sections_again.  */
  68 static int need_laying_out = 0;
  69
  70 /* Maximum size of a group of input sections that can be handled by
  71    one stub section.  A value of +/-1 indicates the bfd back-end
  72    should use a suitable default size.  */
  73 static bfd_signed_vma group_size = 1;
  74
  75 struct hook_stub_info
  76 {
  77   lang_statement_list_type add;
  78   asection *input_section;
  79 };
  80
  81 /* Traverse the linker tree to find the spot where the stub goes.  */
  82
  83 static bfd_boolean
  84 hook_in_stub (struct hook_stub_info *info, lang_statement_union_type **lp)
  85 {
  86   lang_statement_union_type *l;
  87   bfd_boolean ret;
  88
  89   for (; (l = *lp) != NULL; lp = &l->header.next)
  90     {
  91       switch (l->header.type)
  92         {
  93         case lang_constructors_statement_enum:
  94           ret = hook_in_stub (info, &constructor_list.head);
  95           if (ret)
  96             return ret;
  97           break;
  98
  99         case lang_output_section_statement_enum:
 100           ret = hook_in_stub (info,
 101                               &l->output_section_statement.children.head);
 102           if (ret)
 103             return ret;
 104           break;
 105
 106         case lang_wild_statement_enum:
 107           ret = hook_in_stub (info, &l->wild_statement.children.head);
 108           if (ret)
 109             return ret;
 110           break;
 111
 112         case lang_group_statement_enum:
 113           ret = hook_in_stub (info, &l->group_statement.children.head);
 114           if (ret)
 115             return ret;
 116           break;
 117
 118         case lang_input_section_enum:
 119           if (l->input_section.section == info->input_section)
 120             {
 121               /* We've found our section.  Insert the stub immediately
 122                  after its associated input section.  */
 123               *(info->add.tail) = l->header.next;
 124               l->header.next = info->add.head;
 125               return TRUE;
 126             }
 127           break;
 128
 129         case lang_data_statement_enum:
 130         case lang_reloc_statement_enum:
 131         case lang_object_symbols_statement_enum:
 132         case lang_output_statement_enum:
 133         case lang_target_statement_enum:
 134         case lang_input_statement_enum:
 135         case lang_assignment_statement_enum:
 136         case lang_padding_statement_enum:
 137         case lang_address_statement_enum:
 138         case lang_fill_statement_enum:
 139           break;
 140
 141         default:
 142           FAIL ();
 143           break;
 144         }
 145     }
 146   return FALSE;
 147 }
 148
 149
 150 /* Call-back for elf64_aarch64_size_stubs.  */
 151
 152 /* Create a new stub section, and arrange for it to be linked
 153    immediately after INPUT_SECTION.  */
 154
 155 static asection *
 156 elf64_aarch64_add_stub_section (const char *stub_sec_name,
 157                                 asection *input_section)
 158 {
 159   asection *stub_sec;
 160   flagword flags;
 161   asection *output_section;
 162   const char *secname;
 163   lang_output_section_statement_type *os;
 164   struct hook_stub_info info;
 165
 166   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE
 167            | SEC_HAS_CONTENTS | SEC_RELOC | SEC_IN_MEMORY | SEC_KEEP);
 168   stub_sec = bfd_make_section_anyway_with_flags (stub_file->the_bfd,
 169                                                  stub_sec_name, flags);
 170   if (stub_sec == NULL)
 171     goto err_ret;
 172
 173   bfd_set_section_alignment (stub_file->the_bfd, stub_sec, 3);
 174
 175   output_section = input_section->output_section;
 176   secname = bfd_get_section_name (output_section->owner, output_section);
 177   os = lang_output_section_find (secname);
 178
 179   info.input_section = input_section;
 180   lang_list_init (&info.add);
 181   lang_add_section (&info.add, stub_sec, NULL, os);
 182
 183   if (info.add.head == NULL)
 184     goto err_ret;
 185
 186   if (hook_in_stub (&info, &os->children.head))
 187     return stub_sec;
 188
 189  err_ret:
 190   einfo ("%X%P: can not make stub section: %E\n");
 191   return NULL;
 192 }
 193
 194 /* Another call-back for elf_arm_size_stubs.  */
 195
 196 static void
 197 gldaarch64_layout_sections_again (void)
 198 {
 199   /* If we have changed sizes of the stub sections, then we need
 200      to recalculate all the section offsets.  This may mean we need to
 201      add even more stubs.  */
 202   gld${EMULATION_NAME}_map_segments (TRUE);
 203   need_laying_out = -1;
 204 }
 205
 206 static void
 207 build_section_lists (lang_statement_union_type *statement)
 208 {
 209   if (statement->header.type == lang_input_section_enum)
 210     {
 211       asection *i = statement->input_section.section;
 212
 213       if (!((lang_input_statement_type *) i->owner->usrdata)->flags.just_syms
 214           && (i->flags & SEC_EXCLUDE) == 0
 215           && i->output_section != NULL
 216           && i->output_section->owner == link_info.output_bfd)
 217         elf64_aarch64_next_input_section (& link_info, i);
 218     }
 219 }
 220
 221 static void
 222 gld${EMULATION_NAME}_after_allocation (void)
 223 {
 224   /* bfd_elf32_discard_info just plays with debugging sections,
 225      ie. doesn't affect any code, so we can delay resizing the
 226      sections.  It's likely we'll resize everything in the process of
 227      adding stubs.  */
 228   if (bfd_elf_discard_info (link_info.output_bfd, & link_info))
 229     need_laying_out = 1;
 230
 231   /* If generating a relocatable output file, then we don't
 232      have to examine the relocs.  */
 233   if (stub_file != NULL && !link_info.relocatable)
 234     {
 235       int ret = elf64_aarch64_setup_section_lists (link_info.output_bfd,
 236                                                    & link_info);
 237
 238       if (ret != 0)
 239         {
 240           if (ret < 0)
 241             {
 242               einfo ("%X%P: could not compute sections lists for stub generation: %E\n");
 243               return;
 244             }
 245
 246           lang_for_each_statement (build_section_lists);
 247
 248           /* Call into the BFD backend to do the real work.  */
 249           if (! elf64_aarch64_size_stubs (link_info.output_bfd,
 250                                           stub_file->the_bfd,
 251                                           & link_info,
 252                                           group_size,
 253                                           & elf64_aarch64_add_stub_section,
 254                                           & gldaarch64_layout_sections_again))
 255             {
 256               einfo ("%X%P: cannot size stub section: %E\n");
 257               return;
 258             }
 259         }
 260     }
 261
 262   if (need_laying_out != -1)
 263     gld${EMULATION_NAME}_map_segments (need_laying_out);
 264 }
 265
 266 static void
 267 gld${EMULATION_NAME}_finish (void)
 268 {
 269   if (! link_info.relocatable)
 270     {
 271       /* Now build the linker stubs.  */
 272       if (stub_file->the_bfd->sections != NULL)
 273         {
 274           if (! elf64_aarch64_build_stubs (& link_info))
 275             einfo ("%X%P: can not build stubs: %E\n");
 276         }
 277     }
 278
 279   finish_default ();
 280 }
 281
 282 /* This is a convenient point to tell BFD about target specific flags.
 283    After the output has been created, but before inputs are read.  */
 284 static void
 285 aarch64_elf_create_output_section_statements (void)
 286 {
 287   if (strstr (bfd_get_target (link_info.output_bfd), "aarch64") == NULL)
 288     {
 289       /* The arm backend needs special fields in the output hash structure.
 290          These will only be created if the output format is an arm format,
 291          hence we do not support linking and changing output formats at the
 292          same time.  Use a link followed by objcopy to change output formats.  */
 293       einfo ("%F%X%P: error: Cannot change output format whilst linking AArch64 binaries.\n");
 294       return;
 295     }
 296
 297   bfd_elf64_aarch64_set_options (link_info.output_bfd, &link_info,
 298                                  no_enum_size_warning,
 299                                  no_wchar_size_warning,
 300                                  pic_veneer);
 301
 302   stub_file = lang_add_input_file ("linker stubs",
 303                                    lang_input_file_is_fake_enum,
 304                                    NULL);
 305   stub_file->the_bfd = bfd_create ("linker stubs", link_info.output_bfd);
 306   if (stub_file->the_bfd == NULL
 307       || ! bfd_set_arch_mach (stub_file->the_bfd,
 308                               bfd_get_arch (link_info.output_bfd),
 309                               bfd_get_mach (link_info.output_bfd)))
 310     {
 311       einfo ("%X%P: can not create BFD %E\n");
 312       return;
 313     }
 314
 315   stub_file->the_bfd->flags |= BFD_LINKER_CREATED;
 316   ldlang_add_file (stub_file);
 317 }
 318
 319 /* Avoid processing the fake stub_file in vercheck, stat_needed and
 320    check_needed routines.  */
 321
 322 static void (*real_func) (lang_input_statement_type *);
 323
 324 static void aarch64_for_each_input_file_wrapper (lang_input_statement_type *l)
 325 {
 326   if (l != stub_file)
 327     (*real_func) (l);
 328 }
 329
 330 static void
 331 aarch64_lang_for_each_input_file (void (*func) (lang_input_statement_type *))
 332 {
 333   real_func = func;
 334   lang_for_each_input_file (&aarch64_for_each_input_file_wrapper);
 335 }
 336
 337 #define lang_for_each_input_file aarch64_lang_for_each_input_file
 338
 339 EOF
 340
 341 # Define some shell vars to insert bits of code into the standard elf
 342 # parse_args and list_options functions.
 343 #
 344 PARSE_AND_LIST_PROLOGUE='
 345 #define OPTION_NO_ENUM_SIZE_WARNING     309
 346 #define OPTION_PIC_VENEER               310
 347 #define OPTION_STUBGROUP_SIZE           311
 348 #define OPTION_NO_WCHAR_SIZE_WARNING    312
 349 '
 350
 351 PARSE_AND_LIST_SHORTOPTS=p
 352
 353 PARSE_AND_LIST_LONGOPTS='
 354   { "no-pipeline-knowledge", no_argument, NULL, '\'p\''},
 355   { "no-enum-size-warning", no_argument, NULL, OPTION_NO_ENUM_SIZE_WARNING},
 356   { "pic-veneer", no_argument, NULL, OPTION_PIC_VENEER},
 357   { "stub-group-size", required_argument, NULL, OPTION_STUBGROUP_SIZE },
 358   { "no-wchar-size-warning", no_argument, NULL, OPTION_NO_WCHAR_SIZE_WARNING},
 359 '
 360
 361 PARSE_AND_LIST_OPTIONS='
 362   fprintf (file, _("  --no-enum-size-warning      Don'\''t warn about objects with incompatible\n"
 363                    "                                enum sizes\n"));
 364   fprintf (file, _("  --no-wchar-size-warning     Don'\''t warn about objects with incompatible"
 365                    "                                wchar_t sizes\n"));
 366   fprintf (file, _("  --pic-veneer                Always generate PIC interworking veneers\n"));
 367   fprintf (file, _("\
 368    --stub-group-size=N   Maximum size of a group of input sections that can be\n\
 369                            handled by one stub section.  A negative value\n\
 370                            locates all stubs after their branches (with a\n\
 371                            group size of -N), while a positive value allows\n\
 372                            two groups of input sections, one before, and one\n\
 373                            after each stub section.  Values of +/-1 indicate\n\
 374                            the linker should choose suitable defaults.\n"
 375                    ));
 376 '
 377
 378 PARSE_AND_LIST_ARGS_CASES='
 379     case '\'p\'':
 380       /* Only here for backwards compatibility.  */
 381       break;
 382
 383     case OPTION_NO_ENUM_SIZE_WARNING:
 384       no_enum_size_warning = 1;
 385       break;
 386
 387     case OPTION_NO_WCHAR_SIZE_WARNING:
 388       no_wchar_size_warning = 1;
 389       break;
 390
 391     case OPTION_PIC_VENEER:
 392       pic_veneer = 1;
 393       break;
 394
 395     case OPTION_STUBGROUP_SIZE:
 396       {
 397         const char *end;
 398
 399         group_size = bfd_scan_vma (optarg, &end, 0);
 400         if (*end)
 401           einfo (_("%P%F: invalid number `%s'\''\n"), optarg);
 402       }
 403       break;
 404 '
 405
 406 # We have our own before_allocation etc. functions, but they call
 407 # the standard routines, so give them a different name.
 408 LDEMUL_BEFORE_ALLOCATION=aarch64_elf_before_allocation
 409 LDEMUL_AFTER_ALLOCATION=gld${EMULATION_NAME}_after_allocation
 410 LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS=aarch64_elf_create_output_section_statements
 411
 412 # Replace the elf before_parse function with our own.
 413 LDEMUL_BEFORE_PARSE=gld"${EMULATION_NAME}"_before_parse
 414
 415 # Call the extra arm-elf function
 416 LDEMUL_FINISH=gld${EMULATION_NAME}_finish