ld/emultempl/armelf.em

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