ld/emultempl/armelf.em

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