ld/emultempl/armelf.em

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