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