ld/emultempl/armelf.em

   1 # This shell script emits a C file. -*- C -*-
   2 #   Copyright (C) 1991-2020 Free Software Foundation, Inc.
   3 #
   4 # This file is part of the 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
  22 # This file is sourced from elf.em, and defines extra arm-elf
  23 # specific routines.
  24 #
  25 test -z "$TARGET2_TYPE" && TARGET2_TYPE="rel"
  26 fragment <<EOF
  27
  28 #include "ldctor.h"
  29 #include "elf/arm.h"
  30 #include "elf32-arm.h"
  31
  32 static struct elf32_arm_params params =
  33 {
  34   NULL,                         /* thumb_entry_symbol */
  35   0,                            /* byteswap_code */
  36   0${TARGET1_IS_REL},           /* target1_is_rel */
  37   "${TARGET2_TYPE}",            /* target2_type */
  38   0,                            /* fix_v4bx */
  39   0,                            /* use_blx */
  40   BFD_ARM_VFP11_FIX_DEFAULT,    /* vfp11_denorm_fix */
  41   BFD_ARM_STM32L4XX_FIX_NONE,   /* stm32l4xx_fix */
  42   0,                            /* no_enum_size_warning */
  43   0,                            /* no_wchar_size_warning */
  44   0,                            /* pic_veneer */
  45   -1,                           /* fix_cortex_a8 */
  46   1,                            /* fix_arm1176 */
  47   -1,                           /* merge_exidx_entries */
  48   0,                            /* cmse_implib */
  49   NULL                          /* in_implib_bfd */
  50 };
  51 static char *in_implib_filename = NULL;
  52
  53 static void
  54 gld${EMULATION_NAME}_before_parse (void)
  55 {
  56 #ifndef TARGET_                 /* I.e., if not generic.  */
  57   ldfile_set_output_arch ("`echo ${ARCH}`", bfd_arch_unknown);
  58 #endif /* not TARGET_ */
  59   input_flags.dynamic = ${DYNAMIC_LINK-TRUE};
  60   config.has_shared = `if test -n "$GENERATE_SHLIB_SCRIPT" ; then echo TRUE ; else echo FALSE ; fi`;
  61   config.separate_code = `if test "x${SEPARATE_CODE}" = xyes ; then echo TRUE ; else echo FALSE ; fi`;
  62   link_info.check_relocs_after_open_input = TRUE;
  63   link_info.relro = DEFAULT_LD_Z_RELRO;
  64 }
  65
  66 static void
  67 gld${EMULATION_NAME}_set_symbols (void)
  68 {
  69   /* PR 19106: The section resizing code in gldarmelf_after_allocation
  70      is effectively the same as relaxation, so prevent early memory
  71      region checks which produce bogus error messages.
  72      Note - this test has nothing to do with symbols.  It is just here
  73      because this is the first emulation routine that is called after
  74      the command line has been parsed.  */
  75   if (!bfd_link_relocatable (&link_info))
  76     TARGET_ENABLE_RELAXATION;
  77 }
  78
  79 static void
  80 arm_elf_before_allocation (void)
  81 {
  82   bfd_elf32_arm_set_byteswap_code (&link_info, params.byteswap_code);
  83
  84   /* Choose type of VFP11 erratum fix, or warn if specified fix is unnecessary
  85      due to architecture version.  */
  86   bfd_elf32_arm_set_vfp11_fix (link_info.output_bfd, &link_info);
  87
  88   /* Choose type of STM32L4XX erratum fix, or warn if specified fix is
  89      unnecessary due to architecture version.  */
  90   bfd_elf32_arm_set_stm32l4xx_fix (link_info.output_bfd, &link_info);
  91
  92   /* Auto-select Cortex-A8 erratum fix if it wasn't explicitly specified.  */
  93   bfd_elf32_arm_set_cortex_a8_fix (link_info.output_bfd, &link_info);
  94
  95   /* Ensure the output sections of veneers needing a dedicated one is not
  96      removed.  */
  97   bfd_elf32_arm_keep_private_stub_output_sections (&link_info);
  98
  99   /* We should be able to set the size of the interworking stub section.  We
 100      can't do it until later if we have dynamic sections, though.  */
 101   if (elf_hash_table (&link_info)->dynobj == NULL)
 102     {
 103       /* Here we rummage through the found bfds to collect glue information.  */
 104       LANG_FOR_EACH_INPUT_STATEMENT (is)
 105         {
 106           /* Initialise mapping tables for code/data.  */
 107           bfd_elf32_arm_init_maps (is->the_bfd);
 108
 109           if (!bfd_elf32_arm_process_before_allocation (is->the_bfd,
 110                                                         &link_info)
 111               || !bfd_elf32_arm_vfp11_erratum_scan (is->the_bfd, &link_info)
 112               || !bfd_elf32_arm_stm32l4xx_erratum_scan (is->the_bfd,
 113                                                         &link_info))
 114             /* xgettext:c-format */
 115             einfo (_("%P: errors encountered processing file %s\n"),
 116                    is->filename);
 117         }
 118
 119       /* We have seen it all.  Allocate it, and carry on.  */
 120       bfd_elf32_arm_allocate_interworking_sections (& link_info);
 121     }
 122
 123   /* Call the standard elf routine.  */
 124   gld${EMULATION_NAME}_before_allocation ();
 125 }
 126
 127 /* Fake input file for stubs.  */
 128 static lang_input_statement_type *stub_file;
 129
 130 /* Whether we need to call gldarm_layout_sections_again.  */
 131 static int need_laying_out = 0;
 132
 133 /* Maximum size of a group of input sections that can be handled by
 134    one stub section.  A value of +/-1 indicates the bfd back-end
 135    should use a suitable default size.  */
 136 static bfd_signed_vma group_size = 1;
 137
 138 struct hook_stub_info
 139 {
 140   lang_statement_list_type add;
 141   asection *input_section;
 142 };
 143
 144 /* Traverse the linker tree to find the spot where the stub goes.  */
 145
 146 static bfd_boolean
 147 hook_in_stub (struct hook_stub_info *info, lang_statement_union_type **lp)
 148 {
 149   lang_statement_union_type *l;
 150   bfd_boolean ret;
 151
 152   for (; (l = *lp) != NULL; lp = &l->header.next)
 153     {
 154       switch (l->header.type)
 155         {
 156         case lang_constructors_statement_enum:
 157           ret = hook_in_stub (info, &constructor_list.head);
 158           if (ret)
 159             return ret;
 160           break;
 161
 162         case lang_output_section_statement_enum:
 163           ret = hook_in_stub (info,
 164                               &l->output_section_statement.children.head);
 165           if (ret)
 166             return ret;
 167           break;
 168
 169         case lang_wild_statement_enum:
 170           ret = hook_in_stub (info, &l->wild_statement.children.head);
 171           if (ret)
 172             return ret;
 173           break;
 174
 175         case lang_group_statement_enum:
 176           ret = hook_in_stub (info, &l->group_statement.children.head);
 177           if (ret)
 178             return ret;
 179           break;
 180
 181         case lang_input_section_enum:
 182           if (l->input_section.section == info->input_section)
 183             {
 184               /* We've found our section.  Insert the stub immediately
 185                  after its associated input section.  */
 186               *(info->add.tail) = l->header.next;
 187               l->header.next = info->add.head;
 188               return TRUE;
 189             }
 190           break;
 191
 192         case lang_data_statement_enum:
 193         case lang_reloc_statement_enum:
 194         case lang_object_symbols_statement_enum:
 195         case lang_output_statement_enum:
 196         case lang_target_statement_enum:
 197         case lang_input_statement_enum:
 198         case lang_assignment_statement_enum:
 199         case lang_padding_statement_enum:
 200         case lang_address_statement_enum:
 201         case lang_fill_statement_enum:
 202           break;
 203
 204         default:
 205           FAIL ();
 206           break;
 207         }
 208     }
 209   return FALSE;
 210 }
 211
 212
 213 /* Call-back for elf32_arm_size_stubs.  */
 214
 215 /* Create a new stub section, and arrange for it to be linked
 216    immediately after INPUT_SECTION.  */
 217
 218 static asection *
 219 elf32_arm_add_stub_section (const char * stub_sec_name,
 220                             asection *   output_section,
 221                             asection *   after_input_section,
 222                             unsigned int alignment_power)
 223 {
 224   asection *stub_sec;
 225   flagword flags;
 226   lang_output_section_statement_type *os;
 227   struct hook_stub_info info;
 228
 229   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE
 230            | SEC_HAS_CONTENTS | SEC_RELOC | SEC_IN_MEMORY | SEC_KEEP);
 231   stub_sec = bfd_make_section_anyway_with_flags (stub_file->the_bfd,
 232                                                  stub_sec_name, flags);
 233   if (stub_sec == NULL)
 234     goto err_ret;
 235
 236   bfd_set_section_alignment (stub_sec, alignment_power);
 237
 238   os = lang_output_section_get (output_section);
 239
 240   info.input_section = after_input_section;
 241   lang_list_init (&info.add);
 242   lang_add_section (&info.add, stub_sec, NULL, os);
 243
 244   if (info.add.head == NULL)
 245     goto err_ret;
 246
 247   if (after_input_section == NULL)
 248     {
 249       lang_statement_union_type **lp = &os->children.head;
 250       lang_statement_union_type *l, *lprev = NULL;
 251
 252       for (; (l = *lp) != NULL; lp = &l->header.next, lprev = l);
 253
 254       if (lprev)
 255         lprev->header.next = info.add.head;
 256       else
 257         os->children.head = info.add.head;
 258
 259       return stub_sec;
 260     }
 261   else
 262     {
 263       if (hook_in_stub (&info, &os->children.head))
 264         return stub_sec;
 265     }
 266
 267  err_ret:
 268   einfo (_("%X%P: can not make stub section: %E\n"));
 269   return NULL;
 270 }
 271
 272 /* Another call-back for elf_arm_size_stubs.  */
 273
 274 static void
 275 gldarm_layout_sections_again (void)
 276 {
 277   /* If we have changed sizes of the stub sections, then we need
 278      to recalculate all the section offsets.  This may mean we need to
 279      add even more stubs.  */
 280   ldelf_map_segments (TRUE);
 281   need_laying_out = -1;
 282 }
 283
 284 static void
 285 build_section_lists (lang_statement_union_type *statement)
 286 {
 287   if (statement->header.type == lang_input_section_enum)
 288     {
 289       asection *i = statement->input_section.section;
 290
 291       if (i->sec_info_type != SEC_INFO_TYPE_JUST_SYMS
 292           && (i->flags & SEC_EXCLUDE) == 0
 293           && i->output_section != NULL
 294           && i->output_section->owner == link_info.output_bfd)
 295         elf32_arm_next_input_section (& link_info, i);
 296     }
 297 }
 298
 299 static int
 300 compare_output_sec_vma (const void *a, const void *b)
 301 {
 302   asection *asec = *(asection **) a, *bsec = *(asection **) b;
 303   asection *aout = asec->output_section, *bout = bsec->output_section;
 304   bfd_vma avma, bvma;
 305
 306   /* If there's no output section for some reason, compare equal.  */
 307   if (!aout || !bout)
 308     return 0;
 309
 310   avma = aout->vma + asec->output_offset;
 311   bvma = bout->vma + bsec->output_offset;
 312
 313   if (avma > bvma)
 314     return 1;
 315   else if (avma < bvma)
 316     return -1;
 317
 318   return 0;
 319 }
 320
 321 static void
 322 gld${EMULATION_NAME}_after_allocation (void)
 323 {
 324   int ret;
 325
 326   /* Build a sorted list of input text sections, then use that to process
 327      the unwind table index.  */
 328   unsigned int list_size = 10;
 329   asection **sec_list = (asection **)
 330       xmalloc (list_size * sizeof (asection *));
 331   unsigned int sec_count = 0;
 332
 333   LANG_FOR_EACH_INPUT_STATEMENT (is)
 334     {
 335       bfd *abfd = is->the_bfd;
 336       asection *sec;
 337
 338       if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
 339         continue;
 340
 341       for (sec = abfd->sections; sec != NULL; sec = sec->next)
 342         {
 343           asection *out_sec = sec->output_section;
 344
 345           if (out_sec
 346               && elf_section_data (sec)
 347               && elf_section_type (sec) == SHT_PROGBITS
 348               && (elf_section_flags (sec) & SHF_EXECINSTR) != 0
 349               && (sec->flags & SEC_EXCLUDE) == 0
 350               && sec->sec_info_type != SEC_INFO_TYPE_JUST_SYMS
 351               && out_sec != bfd_abs_section_ptr)
 352             {
 353               if (sec_count == list_size)
 354                 {
 355                   list_size *= 2;
 356                   sec_list = (asection **)
 357                       xrealloc (sec_list, list_size * sizeof (asection *));
 358                 }
 359
 360               sec_list[sec_count++] = sec;
 361             }
 362         }
 363     }
 364
 365   qsort (sec_list, sec_count, sizeof (asection *), &compare_output_sec_vma);
 366
 367   if (elf32_arm_fix_exidx_coverage (sec_list, sec_count, &link_info,
 368                                     params.merge_exidx_entries))
 369     need_laying_out = 1;
 370
 371   free (sec_list);
 372
 373   /* bfd_elf32_discard_info just plays with debugging sections,
 374      ie. doesn't affect any code, so we can delay resizing the
 375      sections.  It's likely we'll resize everything in the process of
 376      adding stubs.  */
 377   ret = bfd_elf_discard_info (link_info.output_bfd, & link_info);
 378   if (ret < 0)
 379     {
 380       einfo (_("%X%P: .eh_frame/.stab edit: %E\n"));
 381       return;
 382     }
 383   else if (ret > 0)
 384     need_laying_out = 1;
 385
 386   /* If generating a relocatable output file, then we don't
 387      have to examine the relocs.  */
 388   if (stub_file != NULL && !bfd_link_relocatable (&link_info))
 389     {
 390       ret = elf32_arm_setup_section_lists (link_info.output_bfd, &link_info);
 391       if (ret != 0)
 392         {
 393           if (ret < 0)
 394             {
 395               einfo (_("%X%P: could not compute sections lists "
 396                        "for stub generation: %E\n"));
 397               return;
 398             }
 399
 400           lang_for_each_statement (build_section_lists);
 401
 402           /* Call into the BFD backend to do the real work.  */
 403           if (! elf32_arm_size_stubs (link_info.output_bfd,
 404                                       stub_file->the_bfd,
 405                                       & link_info,
 406                                       group_size,
 407                                       & elf32_arm_add_stub_section,
 408                                       & gldarm_layout_sections_again))
 409             {
 410               einfo (_("%X%P: can not size stub section: %E\n"));
 411               return;
 412             }
 413         }
 414     }
 415
 416   if (need_laying_out != -1)
 417     ldelf_map_segments (need_laying_out);
 418 }
 419
 420 static void
 421 gld${EMULATION_NAME}_finish (void)
 422 {
 423   struct bfd_link_hash_entry * h;
 424
 425   {
 426     LANG_FOR_EACH_INPUT_STATEMENT (is)
 427       {
 428         /* Figure out where VFP11 erratum veneers (and the labels returning
 429            from same) have been placed.  */
 430         bfd_elf32_arm_vfp11_fix_veneer_locations (is->the_bfd, &link_info);
 431
 432          /* Figure out where STM32L4XX erratum veneers (and the labels returning
 433            from them) have been placed.  */
 434         bfd_elf32_arm_stm32l4xx_fix_veneer_locations (is->the_bfd, &link_info);
 435       }
 436   }
 437
 438   if (!bfd_link_relocatable (&link_info))
 439     {
 440       /* Now build the linker stubs.  */
 441       if (stub_file->the_bfd->sections != NULL)
 442         {
 443           if (! elf32_arm_build_stubs (& link_info))
 444             einfo (_("%X%P: can not build stubs: %E\n"));
 445         }
 446     }
 447
 448   finish_default ();
 449
 450   if (params.thumb_entry_symbol)
 451     {
 452       h = bfd_link_hash_lookup (link_info.hash, params.thumb_entry_symbol,
 453                                 FALSE, FALSE, TRUE);
 454     }
 455   else
 456     {
 457       struct elf_link_hash_entry * eh;
 458
 459       if (!entry_symbol.name)
 460         return;
 461
 462       h = bfd_link_hash_lookup (link_info.hash, entry_symbol.name,
 463                                 FALSE, FALSE, TRUE);
 464       eh = (struct elf_link_hash_entry *)h;
 465       if (!h || ARM_GET_SYM_BRANCH_TYPE (eh->target_internal)
 466                 != ST_BRANCH_TO_THUMB)
 467         return;
 468     }
 469
 470
 471   if (h != (struct bfd_link_hash_entry *) NULL
 472       && (h->type == bfd_link_hash_defined
 473           || h->type == bfd_link_hash_defweak)
 474       && h->u.def.section->output_section != NULL)
 475     {
 476       static char buffer[32];
 477       bfd_vma val;
 478
 479       /* Special procesing is required for a Thumb entry symbol.  The
 480          bottom bit of its address must be set.  */
 481       val = (h->u.def.value
 482              + bfd_section_vma (h->u.def.section->output_section)
 483              + h->u.def.section->output_offset);
 484
 485       val |= 1;
 486
 487       /* Now convert this value into a string and store it in entry_symbol
 488          where the lang_finish() function will pick it up.  */
 489       buffer[0] = '0';
 490       buffer[1] = 'x';
 491
 492       sprintf_vma (buffer + 2, val);
 493
 494       if (params.thumb_entry_symbol != NULL && entry_symbol.name != NULL
 495           && entry_from_cmdline)
 496         einfo (_("%P: warning: '--thumb-entry %s' is overriding '-e %s'\n"),
 497                params.thumb_entry_symbol, entry_symbol.name);
 498       entry_symbol.name = buffer;
 499     }
 500   else
 501     einfo (_("%P: warning: cannot find thumb start symbol %s\n"),
 502            h->root.string);
 503 }
 504
 505 /* This is a convenient point to tell BFD about target specific flags.
 506    After the output has been created, but before inputs are read.  */
 507 static void
 508 arm_elf_create_output_section_statements (void)
 509 {
 510   if (strstr (bfd_get_target (link_info.output_bfd), "arm") == NULL)
 511     {
 512       /* The arm backend needs special fields in the output hash structure.
 513          These will only be created if the output format is an arm format,
 514          hence we do not support linking and changing output formats at the
 515          same time.  Use a link followed by objcopy to change output formats.  */
 516       einfo (_("%F%P: error: cannot change output format "
 517                "whilst linking %s binaries\n"), "ARM");
 518       return;
 519     }
 520
 521   if (in_implib_filename)
 522     {
 523       params.in_implib_bfd = bfd_openr (in_implib_filename,
 524                                         bfd_get_target (link_info.output_bfd));
 525
 526       if (params.in_implib_bfd == NULL)
 527         einfo (_("%F%P: %s: can't open: %E\n"), in_implib_filename);
 528
 529       if (!bfd_check_format (params.in_implib_bfd, bfd_object))
 530         einfo (_("%F%P: %s: not a relocatable file: %E\n"), in_implib_filename);
 531     }
 532
 533   bfd_elf32_arm_set_target_params (link_info.output_bfd, &link_info, &params);
 534
 535   stub_file = lang_add_input_file ("linker stubs",
 536                                    lang_input_file_is_fake_enum,
 537                                    NULL);
 538   stub_file->the_bfd = bfd_create ("linker stubs", link_info.output_bfd);
 539   if (stub_file->the_bfd == NULL
 540       || ! bfd_set_arch_mach (stub_file->the_bfd,
 541                               bfd_get_arch (link_info.output_bfd),
 542                               bfd_get_mach (link_info.output_bfd)))
 543     {
 544       einfo (_("%F%P: can not create BFD: %E\n"));
 545       return;
 546     }
 547
 548   stub_file->the_bfd->flags |= BFD_LINKER_CREATED;
 549   ldlang_add_file (stub_file);
 550
 551   /* Also use the stub file for stubs placed in a single output section.  */
 552   bfd_elf32_arm_add_glue_sections_to_bfd (stub_file->the_bfd, &link_info);
 553   bfd_elf32_arm_get_bfd_for_interworking (stub_file->the_bfd, &link_info);
 554 }
 555
 556 EOF
 557
 558 # Define some shell vars to insert bits of code into the standard elf
 559 # parse_args and list_options functions.
 560 #
 561 PARSE_AND_LIST_PROLOGUE='
 562 #define OPTION_THUMB_ENTRY              301
 563 #define OPTION_BE8                      302
 564 #define OPTION_TARGET1_REL              303
 565 #define OPTION_TARGET1_ABS              304
 566 #define OPTION_TARGET2                  305
 567 #define OPTION_FIX_V4BX                 306
 568 #define OPTION_USE_BLX                  307
 569 #define OPTION_VFP11_DENORM_FIX         308
 570 #define OPTION_NO_ENUM_SIZE_WARNING     309
 571 #define OPTION_PIC_VENEER               310
 572 #define OPTION_FIX_V4BX_INTERWORKING    311
 573 #define OPTION_STUBGROUP_SIZE           312
 574 #define OPTION_NO_WCHAR_SIZE_WARNING    313
 575 #define OPTION_FIX_CORTEX_A8            314
 576 #define OPTION_NO_FIX_CORTEX_A8         315
 577 #define OPTION_NO_MERGE_EXIDX_ENTRIES   316
 578 #define OPTION_FIX_ARM1176              317
 579 #define OPTION_NO_FIX_ARM1176           318
 580 #define OPTION_LONG_PLT                 319
 581 #define OPTION_STM32L4XX_FIX            320
 582 #define OPTION_CMSE_IMPLIB              321
 583 #define OPTION_IN_IMPLIB                322
 584 '
 585
 586 PARSE_AND_LIST_SHORTOPTS=p
 587
 588 PARSE_AND_LIST_LONGOPTS='
 589   { "no-pipeline-knowledge", no_argument, NULL, '\'p\''},
 590   { "thumb-entry", required_argument, NULL, OPTION_THUMB_ENTRY},
 591   { "be8", no_argument, NULL, OPTION_BE8},
 592   { "target1-rel", no_argument, NULL, OPTION_TARGET1_REL},
 593   { "target1-abs", no_argument, NULL, OPTION_TARGET1_ABS},
 594   { "target2", required_argument, NULL, OPTION_TARGET2},
 595   { "fix-v4bx", no_argument, NULL, OPTION_FIX_V4BX},
 596   { "fix-v4bx-interworking", no_argument, NULL, OPTION_FIX_V4BX_INTERWORKING},
 597   { "use-blx", no_argument, NULL, OPTION_USE_BLX},
 598   { "vfp11-denorm-fix", required_argument, NULL, OPTION_VFP11_DENORM_FIX},
 599   { "fix-stm32l4xx-629360", optional_argument, NULL, OPTION_STM32L4XX_FIX},
 600   { "no-enum-size-warning", no_argument, NULL, OPTION_NO_ENUM_SIZE_WARNING},
 601   { "pic-veneer", no_argument, NULL, OPTION_PIC_VENEER},
 602   { "stub-group-size", required_argument, NULL, OPTION_STUBGROUP_SIZE },
 603   { "no-wchar-size-warning", no_argument, NULL, OPTION_NO_WCHAR_SIZE_WARNING},
 604   { "fix-cortex-a8", no_argument, NULL, OPTION_FIX_CORTEX_A8 },
 605   { "no-fix-cortex-a8", no_argument, NULL, OPTION_NO_FIX_CORTEX_A8 },
 606   { "no-merge-exidx-entries", no_argument, NULL, OPTION_NO_MERGE_EXIDX_ENTRIES },
 607   { "fix-arm1176", no_argument, NULL, OPTION_FIX_ARM1176 },
 608   { "no-fix-arm1176", no_argument, NULL, OPTION_NO_FIX_ARM1176 },
 609   { "long-plt", no_argument, NULL, OPTION_LONG_PLT },
 610   { "cmse-implib", no_argument, NULL, OPTION_CMSE_IMPLIB },
 611   { "in-implib", required_argument, NULL, OPTION_IN_IMPLIB },
 612 '
 613
 614 PARSE_AND_LIST_OPTIONS='
 615   fprintf (file, _("  --thumb-entry=<sym>         Set the entry point to be Thumb symbol <sym>\n"));
 616   fprintf (file, _("  --be8                       Output BE8 format image\n"));
 617   fprintf (file, _("  --target1-rel               Interpret R_ARM_TARGET1 as R_ARM_REL32\n"));
 618   fprintf (file, _("  --target1-abs               Interpret R_ARM_TARGET1 as R_ARM_ABS32\n"));
 619   fprintf (file, _("  --target2=<type>            Specify definition of R_ARM_TARGET2\n"));
 620   fprintf (file, _("  --fix-v4bx                  Rewrite BX rn as MOV pc, rn for ARMv4\n"));
 621   fprintf (file, _("  --fix-v4bx-interworking     Rewrite BX rn branch to ARMv4 interworking veneer\n"));
 622   fprintf (file, _("  --use-blx                   Enable use of BLX instructions\n"));
 623   fprintf (file, _("  --vfp11-denorm-fix          Specify how to fix VFP11 denorm erratum\n"));
 624   fprintf (file, _("  --fix-stm32l4xx-629360      Specify how to fix STM32L4XX 629360 erratum\n"));
 625   fprintf (file, _("  --no-enum-size-warning      Don'\''t warn about objects with incompatible\n"
 626                    "                                enum sizes\n"));
 627   fprintf (file, _("  --no-wchar-size-warning     Don'\''t warn about objects with incompatible\n"
 628                    "                                wchar_t sizes\n"));
 629   fprintf (file, _("  --pic-veneer                Always generate PIC interworking veneers\n"));
 630   fprintf (file, _("  --long-plt                  Generate long .plt entries\n"
 631            "                              to handle large .plt/.got displacements\n"));
 632   fprintf (file, _("  --cmse-implib               Make import library to be a secure gateway import\n"
 633                    "                                library as per ARMv8-M Security Extensions\n"));
 634   fprintf (file, _("  --in-implib                 Import library whose symbols address must\n"
 635                    "                                remain stable\n"));
 636   fprintf (file, _("\
 637   --stub-group-size=N         Maximum size of a group of input sections that\n\
 638                                 can be handled by one stub section.  A negative\n\
 639                                 value locates all stubs after their branches\n\
 640                                 (with a group size of -N), while a positive\n\
 641                                 value allows two groups of input sections, one\n\
 642                                 before, and one after each stub section.\n\
 643                                 Values of +/-1 indicate the linker should\n\
 644                                 choose suitable defaults.\n"));
 645   fprintf (file, _("  --[no-]fix-cortex-a8        Disable/enable Cortex-A8 Thumb-2 branch erratum fix\n"));
 646   fprintf (file, _("  --no-merge-exidx-entries    Disable merging exidx entries\n"));
 647   fprintf (file, _("  --[no-]fix-arm1176          Disable/enable ARM1176 BLX immediate erratum fix\n"));
 648 '
 649
 650 PARSE_AND_LIST_ARGS_CASES='
 651     case '\'p\'':
 652       /* Only here for backwards compatibility.  */
 653       break;
 654
 655     case OPTION_THUMB_ENTRY:
 656       params.thumb_entry_symbol = optarg;
 657       break;
 658
 659     case OPTION_BE8:
 660       params.byteswap_code = 1;
 661       break;
 662
 663     case OPTION_TARGET1_REL:
 664       params.target1_is_rel = 1;
 665       break;
 666
 667     case OPTION_TARGET1_ABS:
 668       params.target1_is_rel = 0;
 669       break;
 670
 671     case OPTION_TARGET2:
 672       params.target2_type = optarg;
 673       break;
 674
 675     case OPTION_FIX_V4BX:
 676       params.fix_v4bx = 1;
 677       break;
 678
 679     case OPTION_FIX_V4BX_INTERWORKING:
 680       params.fix_v4bx = 2;
 681       break;
 682
 683     case OPTION_USE_BLX:
 684       params.use_blx = 1;
 685       break;
 686
 687     case OPTION_VFP11_DENORM_FIX:
 688       if (strcmp (optarg, "none") == 0)
 689         params.vfp11_denorm_fix = BFD_ARM_VFP11_FIX_NONE;
 690       else if (strcmp (optarg, "scalar") == 0)
 691         params.vfp11_denorm_fix = BFD_ARM_VFP11_FIX_SCALAR;
 692       else if (strcmp (optarg, "vector") == 0)
 693         params.vfp11_denorm_fix = BFD_ARM_VFP11_FIX_VECTOR;
 694       else
 695         einfo (_("%P: unrecognized VFP11 fix type '\''%s'\''\n"), optarg);
 696       break;
 697
 698     case OPTION_STM32L4XX_FIX:
 699       if (!optarg)
 700         params.stm32l4xx_fix = BFD_ARM_STM32L4XX_FIX_DEFAULT;
 701       else if (strcmp (optarg, "none") == 0)
 702         params.stm32l4xx_fix = BFD_ARM_STM32L4XX_FIX_NONE;
 703       else if (strcmp (optarg, "default") == 0)
 704         params.stm32l4xx_fix = BFD_ARM_STM32L4XX_FIX_DEFAULT;
 705       else if (strcmp (optarg, "all") == 0)
 706         params.stm32l4xx_fix = BFD_ARM_STM32L4XX_FIX_ALL;
 707       else
 708         einfo (_("%P: unrecognized STM32L4XX fix type '\''%s'\''\n"), optarg);
 709       break;
 710
 711     case OPTION_NO_ENUM_SIZE_WARNING:
 712       params.no_enum_size_warning = 1;
 713       break;
 714
 715     case OPTION_NO_WCHAR_SIZE_WARNING:
 716       params.no_wchar_size_warning = 1;
 717       break;
 718
 719     case OPTION_PIC_VENEER:
 720       params.pic_veneer = 1;
 721       break;
 722
 723     case OPTION_STUBGROUP_SIZE:
 724       {
 725         const char *end;
 726
 727         group_size = bfd_scan_vma (optarg, &end, 0);
 728         if (*end)
 729           einfo (_("%F%P: invalid number `%s'\''\n"), optarg);
 730       }
 731       break;
 732
 733     case OPTION_FIX_CORTEX_A8:
 734       params.fix_cortex_a8 = 1;
 735       break;
 736
 737     case OPTION_NO_FIX_CORTEX_A8:
 738       params.fix_cortex_a8 = 0;
 739       break;
 740
 741    case OPTION_NO_MERGE_EXIDX_ENTRIES:
 742       params.merge_exidx_entries = 0;
 743       break;
 744
 745    case OPTION_FIX_ARM1176:
 746       params.fix_arm1176 = 1;
 747       break;
 748
 749    case OPTION_NO_FIX_ARM1176:
 750       params.fix_arm1176 = 0;
 751       break;
 752
 753    case OPTION_LONG_PLT:
 754       bfd_elf32_arm_use_long_plt ();
 755       break;
 756
 757    case OPTION_CMSE_IMPLIB:
 758       params.cmse_implib = 1;
 759       break;
 760
 761    case OPTION_IN_IMPLIB:
 762       in_implib_filename = optarg;
 763       break;
 764 '
 765
 766 # We have our own before_allocation etc. functions, but they call
 767 # the standard routines, so give them a different name.
 768 LDEMUL_BEFORE_ALLOCATION=arm_elf_before_allocation
 769 LDEMUL_AFTER_ALLOCATION=gld${EMULATION_NAME}_after_allocation
 770 LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS=arm_elf_create_output_section_statements
 771
 772 # Replace the elf before_parse function with our own.
 773 LDEMUL_BEFORE_PARSE=gld"${EMULATION_NAME}"_before_parse
 774 LDEMUL_SET_SYMBOLS=gld"${EMULATION_NAME}"_set_symbols
 775
 776 # Call the extra arm-elf function
 777 LDEMUL_FINISH=gld${EMULATION_NAME}_finish