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