ld/emultempl/armelf.em

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