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