ld/emultempl/armelf.em

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