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