1# This shell script emits a C file. -*- C -*- 2# Copyright (C) 2002-2020 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 powerpc64-elf 23# specific routines. 24# 25fragment <<EOF 26 27#include "ldctor.h" 28#include "elf-bfd.h" 29#include "elf64-ppc.h" 30#include "ldlex.h" 31#include "elf/ppc64.h" 32 33static asection *ppc_add_stub_section (const char *, asection *); 34static void ppc_layout_sections_again (void); 35 36static struct ppc64_elf_params params = { NULL, 37 &ppc_add_stub_section, 38 &ppc_layout_sections_again, 39 1, -1, 0, 40 ${DEFAULT_PLT_STATIC_CHAIN-0}, -1, 5, 41 -1, 0, -1, -1, 0}; 42 43/* Fake input file for stubs. */ 44static lang_input_statement_type *stub_file; 45 46/* Whether we need to call ppc_layout_sections_again. */ 47static int need_laying_out = 0; 48 49/* Whether to add ".foo" entries for each "foo" in a version script. */ 50static int dotsyms = 1; 51 52/* Whether to run tls optimization. */ 53static int no_tls_opt = 0; 54 55/* Whether to run opd optimization. */ 56static int no_opd_opt = 0; 57 58/* Whether to convert inline PLT calls to direct. */ 59static int no_inline_opt = 0; 60 61/* Whether to run toc optimization. */ 62static int no_toc_opt = 0; 63 64/* Whether to sort input toc and got sections. */ 65static int no_toc_sort = 0; 66 67/* Input .toc sections will be placed in this output section. */ 68static const char *toc_section_name = ".got"; 69static asection *toc_section = 0; 70 71/* This is called before the input files are opened. We create a new 72 fake input file to hold the stub sections. */ 73 74static void 75ppc_create_output_section_statements (void) 76{ 77 if (!(bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour 78 && elf_object_id (link_info.output_bfd) == PPC64_ELF_DATA)) 79 return; 80 81 link_info.wrap_char = '.'; 82 83 stub_file = lang_add_input_file ("linker stubs", 84 lang_input_file_is_fake_enum, 85 NULL); 86 stub_file->the_bfd = bfd_create ("linker stubs", link_info.output_bfd); 87 if (stub_file->the_bfd == NULL 88 || !bfd_set_arch_mach (stub_file->the_bfd, 89 bfd_get_arch (link_info.output_bfd), 90 bfd_get_mach (link_info.output_bfd))) 91 { 92 einfo (_("%F%P: can not create BFD: %E\n")); 93 return; 94 } 95 96 stub_file->the_bfd->flags |= BFD_LINKER_CREATED; 97 ldlang_add_file (stub_file); 98 params.stub_bfd = stub_file->the_bfd; 99 if (params.save_restore_funcs < 0) 100 params.save_restore_funcs = !bfd_link_relocatable (&link_info); 101 if (!ppc64_elf_init_stub_bfd (&link_info, ¶ms)) 102 einfo (_("%F%P: can not init BFD: %E\n")); 103} 104 105/* Called after opening files but before mapping sections. */ 106 107static void 108ppc_after_open (void) 109{ 110 if (stub_file != NULL && link_info.relro && params.object_in_toc) 111 { 112 /* We have a .toc section that might be written to at run time. 113 Don't put .toc into the .got output section. */ 114 lang_output_section_statement_type *got; 115 116 got = lang_output_section_find (".got"); 117 if (got != NULL) 118 { 119 lang_statement_union_type *s; 120 for (s = got->children.head; s != NULL; s = s->header.next) 121 if (s->header.type == lang_wild_statement_enum 122 && s->wild_statement.filename == NULL) 123 { 124 struct wildcard_list **i = &s->wild_statement.section_list; 125 while (*i != NULL) 126 if (strcmp ((*i)->spec.name, ".toc") == 0) 127 *i = (*i)->next; 128 else 129 i = &(*i)->next; 130 } 131 /* Instead, .toc input sections will be mapped to the 132 read/write .toc output section. If user scripts don't 133 provide one then we'll lose toc sorting and multi-toc. */ 134 toc_section_name = ".toc"; 135 } 136 } 137 gld${EMULATION_NAME}_after_open (); 138} 139 140/* Move the input section statement at *U which happens to be on LIST 141 to be just before *TO. */ 142 143static void 144move_input_section (lang_statement_list_type *list, 145 lang_statement_union_type **u, 146 lang_statement_union_type **to) 147{ 148 lang_statement_union_type *s = *u; 149 asection *i = s->input_section.section; 150 asection *p, *n; 151 152 /* Snip the input section from the statement list. If it was the 153 last statement, fix the list tail pointer. */ 154 *u = s->header.next; 155 if (*u == NULL) 156 list->tail = u; 157 /* Add it back in the new position. */ 158 s->header.next = *to; 159 *to = s; 160 if (list->tail == to) 161 list->tail = &s->header.next; 162 163 /* Trim I off the bfd map_head/map_tail doubly linked lists. */ 164 n = i->map_head.s; 165 p = i->map_tail.s; 166 (p != NULL ? p : i->output_section)->map_head.s = n; 167 (n != NULL ? n : i->output_section)->map_tail.s = p; 168 169 /* Add I back on in its new position. */ 170 if (s->header.next->header.type == lang_input_section_enum) 171 { 172 n = s->header.next->input_section.section; 173 p = n->map_tail.s; 174 } 175 else 176 { 177 /* If the next statement is not an input section statement then 178 TO must point at the previous input section statement 179 header.next field. */ 180 lang_input_section_type *prev = (lang_input_section_type *) 181 ((char *) to - offsetof (lang_statement_union_type, header.next)); 182 183 ASSERT (prev->header.type == lang_input_section_enum); 184 p = prev->section; 185 n = p->map_head.s; 186 } 187 i->map_head.s = n; 188 i->map_tail.s = p; 189 (p != NULL ? p : i->output_section)->map_head.s = i; 190 (n != NULL ? n : i->output_section)->map_tail.s = i; 191} 192 193/* Sort input section statements in the linker script tree rooted at 194 LIST so that those whose owning bfd happens to have a section 195 called .init or .fini are placed first. Place any TOC sections 196 referenced by small TOC relocs next, with TOC sections referenced 197 only by bigtoc relocs last. */ 198 199static void 200sort_toc_sections (lang_statement_list_type *list, 201 lang_statement_union_type **ini, 202 lang_statement_union_type **small) 203{ 204 lang_statement_union_type *s, **u; 205 asection *i; 206 207 u = &list->head; 208 while ((s = *u) != NULL) 209 { 210 switch (s->header.type) 211 { 212 case lang_wild_statement_enum: 213 sort_toc_sections (&s->wild_statement.children, ini, small); 214 break; 215 216 case lang_group_statement_enum: 217 sort_toc_sections (&s->group_statement.children, ini, small); 218 break; 219 220 case lang_input_section_enum: 221 i = s->input_section.section; 222 /* Leave the stub_file .got where it is. We put the .got 223 header there. */ 224 if (i->owner == stub_file->the_bfd) 225 break; 226 if (bfd_get_section_by_name (i->owner, ".init") != NULL 227 || bfd_get_section_by_name (i->owner, ".fini") != NULL) 228 { 229 if (ini != NULL && *ini != s) 230 { 231 move_input_section (list, u, ini); 232 if (small == ini) 233 small = &s->header.next; 234 ini = &s->header.next; 235 continue; 236 } 237 if (small == ini) 238 small = &s->header.next; 239 ini = &s->header.next; 240 break; 241 } 242 else if (ini == NULL) 243 ini = u; 244 245 if (ppc64_elf_has_small_toc_reloc (i)) 246 { 247 if (small != NULL && *small != s) 248 { 249 move_input_section (list, u, small); 250 small = &s->header.next; 251 continue; 252 } 253 small = &s->header.next; 254 } 255 else if (small == NULL) 256 small = u; 257 break; 258 259 default: 260 break; 261 } 262 u = &s->header.next; 263 } 264} 265 266static void 267prelim_size_sections (void) 268{ 269 if (expld.phase != lang_mark_phase_enum) 270 { 271 expld.phase = lang_mark_phase_enum; 272 expld.dataseg.phase = exp_seg_none; 273 one_lang_size_sections_pass (NULL, FALSE); 274 /* We must not cache anything from the preliminary sizing. */ 275 lang_reset_memory_regions (); 276 } 277} 278 279static void 280ppc_before_allocation (void) 281{ 282 if (stub_file != NULL) 283 { 284 if (!no_opd_opt 285 && !ppc64_elf_edit_opd (&link_info)) 286 einfo (_("%X%P: can not edit %s: %E\n"), "opd"); 287 288 if (!no_inline_opt 289 && !bfd_link_relocatable (&link_info)) 290 { 291 prelim_size_sections (); 292 293 if (!ppc64_elf_inline_plt (&link_info)) 294 einfo (_("%X%P: inline PLT: %E\n")); 295 } 296 297 if (ppc64_elf_tls_setup (&link_info) 298 && !no_tls_opt) 299 { 300 /* Size the sections. This is premature, but we want to know the 301 TLS segment layout so that certain optimizations can be done. */ 302 prelim_size_sections (); 303 304 if (!ppc64_elf_tls_optimize (&link_info)) 305 einfo (_("%X%P: TLS problem %E\n")); 306 } 307 308 if (!no_toc_opt 309 && !bfd_link_relocatable (&link_info)) 310 { 311 prelim_size_sections (); 312 313 if (!ppc64_elf_edit_toc (&link_info)) 314 einfo (_("%X%P: can not edit %s: %E\n"), "toc"); 315 } 316 317 if (!no_toc_sort) 318 { 319 lang_output_section_statement_type *toc_os; 320 321 toc_os = lang_output_section_find (toc_section_name); 322 if (toc_os != NULL) 323 sort_toc_sections (&toc_os->children, NULL, NULL); 324 } 325 } 326 327 gld${EMULATION_NAME}_before_allocation (); 328} 329 330struct hook_stub_info 331{ 332 lang_statement_list_type add; 333 asection *input_section; 334}; 335 336/* Traverse the linker tree to find the spot where the stub goes. */ 337 338static bfd_boolean 339hook_in_stub (struct hook_stub_info *info, lang_statement_union_type **lp) 340{ 341 lang_statement_union_type *l; 342 bfd_boolean ret; 343 344 for (; (l = *lp) != NULL; lp = &l->header.next) 345 { 346 switch (l->header.type) 347 { 348 case lang_constructors_statement_enum: 349 ret = hook_in_stub (info, &constructor_list.head); 350 if (ret) 351 return ret; 352 break; 353 354 case lang_output_section_statement_enum: 355 ret = hook_in_stub (info, 356 &l->output_section_statement.children.head); 357 if (ret) 358 return ret; 359 break; 360 361 case lang_wild_statement_enum: 362 ret = hook_in_stub (info, &l->wild_statement.children.head); 363 if (ret) 364 return ret; 365 break; 366 367 case lang_group_statement_enum: 368 ret = hook_in_stub (info, &l->group_statement.children.head); 369 if (ret) 370 return ret; 371 break; 372 373 case lang_input_section_enum: 374 if (l->input_section.section == info->input_section) 375 { 376 /* We've found our section. Insert the stub immediately 377 before its associated input section. */ 378 *lp = info->add.head; 379 *(info->add.tail) = l; 380 return TRUE; 381 } 382 break; 383 384 case lang_data_statement_enum: 385 case lang_reloc_statement_enum: 386 case lang_object_symbols_statement_enum: 387 case lang_output_statement_enum: 388 case lang_target_statement_enum: 389 case lang_input_statement_enum: 390 case lang_assignment_statement_enum: 391 case lang_padding_statement_enum: 392 case lang_address_statement_enum: 393 case lang_fill_statement_enum: 394 break; 395 396 default: 397 FAIL (); 398 break; 399 } 400 } 401 return FALSE; 402} 403 404 405/* Call-back for ppc64_elf_size_stubs. */ 406 407/* Create a new stub section, and arrange for it to be linked 408 immediately before INPUT_SECTION. */ 409 410static asection * 411ppc_add_stub_section (const char *stub_sec_name, asection *input_section) 412{ 413 asection *stub_sec; 414 flagword flags; 415 asection *output_section; 416 lang_output_section_statement_type *os; 417 struct hook_stub_info info; 418 419 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE 420 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_KEEP); 421 stub_sec = bfd_make_section_anyway_with_flags (stub_file->the_bfd, 422 stub_sec_name, flags); 423 if (stub_sec == NULL 424 || !bfd_set_section_alignment (stub_sec, (params.plt_stub_align > 5 425 ? params.plt_stub_align 426 : params.plt_stub_align < -5 427 ? -params.plt_stub_align 428 : 5))) 429 goto err_ret; 430 431 output_section = input_section->output_section; 432 os = lang_output_section_get (output_section); 433 434 info.input_section = input_section; 435 lang_list_init (&info.add); 436 lang_add_section (&info.add, stub_sec, NULL, os); 437 438 if (info.add.head == NULL) 439 goto err_ret; 440 441 if (hook_in_stub (&info, &os->children.head)) 442 return stub_sec; 443 444 err_ret: 445 einfo (_("%X%P: can not make stub section: %E\n")); 446 return NULL; 447} 448 449 450/* Another call-back for ppc64_elf_size_stubs. */ 451 452static void 453ppc_layout_sections_again (void) 454{ 455 /* If we have changed sizes of the stub sections, then we need 456 to recalculate all the section offsets. This may mean we need to 457 add even more stubs. */ 458 ldelf_map_segments (TRUE); 459 460 if (!bfd_link_relocatable (&link_info)) 461 ppc64_elf_set_toc (&link_info, link_info.output_bfd); 462 463 need_laying_out = -1; 464} 465 466 467static void 468build_toc_list (lang_statement_union_type *statement) 469{ 470 if (statement->header.type == lang_input_section_enum) 471 { 472 asection *i = statement->input_section.section; 473 474 if (i->sec_info_type != SEC_INFO_TYPE_JUST_SYMS 475 && (i->flags & SEC_EXCLUDE) == 0 476 && i->output_section == toc_section) 477 { 478 if (!ppc64_elf_next_toc_section (&link_info, i)) 479 einfo (_("%X%P: linker script separates .got and .toc\n")); 480 } 481 } 482} 483 484 485static void 486build_section_lists (lang_statement_union_type *statement) 487{ 488 if (statement->header.type == lang_input_section_enum) 489 { 490 asection *i = statement->input_section.section; 491 492 if (!bfd_input_just_syms (i->owner) 493 && (i->flags & SEC_EXCLUDE) == 0 494 && i->output_section != NULL 495 && i->output_section->owner == link_info.output_bfd) 496 { 497 if (!ppc64_elf_next_input_section (&link_info, i)) 498 einfo (_("%X%P: can not size stub section: %E\n")); 499 } 500 } 501} 502 503 504/* Call the back-end function to set TOC base after we have placed all 505 the sections. */ 506static void 507gld${EMULATION_NAME}_after_allocation (void) 508{ 509 int ret; 510 511 /* If generating a relocatable output file, then we don't have any 512 stubs. */ 513 if (stub_file != NULL && !bfd_link_relocatable (&link_info)) 514 { 515 ret = ppc64_elf_setup_section_lists (&link_info); 516 if (ret < 0) 517 einfo (_("%X%P: can not size stub section: %E\n")); 518 else 519 { 520 ppc64_elf_start_multitoc_partition (&link_info); 521 522 if (!params.no_multi_toc) 523 { 524 toc_section = bfd_get_section_by_name (link_info.output_bfd, 525 toc_section_name); 526 if (toc_section != NULL) 527 lang_for_each_statement (build_toc_list); 528 } 529 530 if (ppc64_elf_layout_multitoc (&link_info) 531 && !params.no_multi_toc 532 && toc_section != NULL) 533 lang_for_each_statement (build_toc_list); 534 535 ppc64_elf_finish_multitoc_partition (&link_info); 536 537 lang_for_each_statement (build_section_lists); 538 539 if (!ppc64_elf_check_init_fini (&link_info)) 540 einfo (_("%P: .init/.fini fragments use differing TOC pointers\n")); 541 542 /* Call into the BFD backend to do the real work. */ 543 if (!ppc64_elf_size_stubs (&link_info)) 544 einfo (_("%X%P: can not size stub section: %E\n")); 545 } 546 } 547 548 /* We can't parse and merge .eh_frame until the glink .eh_frame has 549 been generated. Otherwise the glink .eh_frame CIE won't be 550 merged with other CIEs, and worse, the glink .eh_frame FDEs won't 551 be listed in .eh_frame_hdr. */ 552 ret = bfd_elf_discard_info (link_info.output_bfd, &link_info); 553 if (ret < 0) 554 { 555 einfo (_("%X%P: .eh_frame/.stab edit: %E\n")); 556 return; 557 } 558 else if (ret > 0) 559 need_laying_out = 1; 560 561 /* Call map_segments regardless of the state of need_laying_out. 562 need_laying_out set to -1 means we have just laid everything out, 563 but ppc64_elf_size_stubs strips .branch_lt and .eh_frame if 564 unneeded, after ppc_layout_sections_again. Another call removes 565 these sections from the segment map. Their presence is 566 innocuous except for confusing ELF_SECTION_IN_SEGMENT. */ 567 ldelf_map_segments (need_laying_out > 0); 568 569 if (need_laying_out != -1 && !bfd_link_relocatable (&link_info)) 570 ppc64_elf_set_toc (&link_info, link_info.output_bfd); 571} 572 573 574/* Final emulation specific call. */ 575 576static void 577gld${EMULATION_NAME}_finish (void) 578{ 579 char *msg = NULL; 580 char *line, *endline; 581 582 /* e_entry on PowerPC64 points to the function descriptor for 583 _start. If _start is missing, default to the first function 584 descriptor in the .opd section. */ 585 if (stub_file != NULL 586 && (elf_elfheader (link_info.output_bfd)->e_flags & EF_PPC64_ABI) == 1) 587 entry_section = ".opd"; 588 589 if (params.emit_stub_syms < 0) 590 params.emit_stub_syms = 1; 591 if (stub_file != NULL 592 && !bfd_link_relocatable (&link_info) 593 && !ppc64_elf_build_stubs (&link_info, config.stats ? &msg : NULL)) 594 einfo (_("%X%P: can not build stubs: %E\n")); 595 596 fflush (stdout); 597 for (line = msg; line != NULL; line = endline) 598 { 599 endline = strchr (line, '\n'); 600 if (endline != NULL) 601 *endline++ = '\0'; 602 fprintf (stderr, "%s: %s\n", program_name, line); 603 } 604 fflush (stderr); 605 if (msg != NULL) 606 free (msg); 607 608 finish_default (); 609} 610 611 612/* Add a pattern matching ".foo" for every "foo" in a version script. 613 614 The reason for doing this is that many shared library version 615 scripts export a selected set of functions or data symbols, forcing 616 others local. eg. 617 618 . VERS_1 { 619 . global: 620 . this; that; some; thing; 621 . local: 622 . *; 623 . }; 624 625 To make the above work for PowerPC64, we need to export ".this", 626 ".that" and so on, otherwise only the function descriptor syms are 627 exported. Lack of an exported function code sym may cause a 628 definition to be pulled in from a static library. */ 629 630static struct bfd_elf_version_expr * 631gld${EMULATION_NAME}_new_vers_pattern (struct bfd_elf_version_expr *entry) 632{ 633 struct bfd_elf_version_expr *dot_entry; 634 unsigned int len; 635 char *dot_pat; 636 637 if (!dotsyms 638 || entry->pattern[0] == '.' 639 || (!entry->literal && entry->pattern[0] == '*')) 640 return entry; 641 642 dot_entry = xmalloc (sizeof *dot_entry); 643 *dot_entry = *entry; 644 dot_entry->next = entry; 645 len = strlen (entry->pattern) + 2; 646 dot_pat = xmalloc (len); 647 dot_pat[0] = '.'; 648 memcpy (dot_pat + 1, entry->pattern, len - 1); 649 dot_entry->pattern = dot_pat; 650 dot_entry->script = 1; 651 return dot_entry; 652} 653 654EOF 655 656if grep -q 'ld_elf32_spu_emulation' ldemul-list.h; then 657 fragment <<EOF 658/* Special handling for embedded SPU executables. */ 659extern bfd_boolean embedded_spu_file (lang_input_statement_type *, const char *); 660 661static bfd_boolean 662ppc64_recognized_file (lang_input_statement_type *entry) 663{ 664 if (embedded_spu_file (entry, "-m64")) 665 return TRUE; 666 667 return ldelf_load_symbols (entry); 668} 669EOF 670LDEMUL_RECOGNIZED_FILE=ppc64_recognized_file 671fi 672 673# Define some shell vars to insert bits of code into the standard elf 674# parse_args and list_options functions. 675# 676PARSE_AND_LIST_PROLOGUE=${PARSE_AND_LIST_PROLOGUE}' 677enum ppc64_opt 678{ 679 OPTION_STUBGROUP_SIZE = 321, 680 OPTION_PLT_STATIC_CHAIN, 681 OPTION_NO_PLT_STATIC_CHAIN, 682 OPTION_PLT_THREAD_SAFE, 683 OPTION_NO_PLT_THREAD_SAFE, 684 OPTION_PLT_ALIGN, 685 OPTION_NO_PLT_ALIGN, 686 OPTION_PLT_LOCALENTRY, 687 OPTION_NO_PLT_LOCALENTRY, 688 OPTION_STUBSYMS, 689 OPTION_NO_STUBSYMS, 690 OPTION_SAVRES, 691 OPTION_NO_SAVRES, 692 OPTION_DOTSYMS, 693 OPTION_NO_DOTSYMS, 694 OPTION_NO_TLS_OPT, 695 OPTION_TLS_GET_ADDR_OPT, 696 OPTION_NO_TLS_GET_ADDR_OPT, 697 OPTION_NO_OPD_OPT, 698 OPTION_NO_INLINE_OPT, 699 OPTION_NO_TOC_OPT, 700 OPTION_NO_MULTI_TOC, 701 OPTION_NO_TOC_SORT, 702 OPTION_NON_OVERLAPPING_OPD 703}; 704' 705 706PARSE_AND_LIST_LONGOPTS=${PARSE_AND_LIST_LONGOPTS}' 707 { "stub-group-size", required_argument, NULL, OPTION_STUBGROUP_SIZE }, 708 { "plt-static-chain", no_argument, NULL, OPTION_PLT_STATIC_CHAIN }, 709 { "no-plt-static-chain", no_argument, NULL, OPTION_NO_PLT_STATIC_CHAIN }, 710 { "plt-thread-safe", no_argument, NULL, OPTION_PLT_THREAD_SAFE }, 711 { "no-plt-thread-safe", no_argument, NULL, OPTION_NO_PLT_THREAD_SAFE }, 712 { "plt-align", optional_argument, NULL, OPTION_PLT_ALIGN }, 713 { "no-plt-align", no_argument, NULL, OPTION_NO_PLT_ALIGN }, 714 { "plt-localentry", optional_argument, NULL, OPTION_PLT_LOCALENTRY }, 715 { "no-plt-localentry", no_argument, NULL, OPTION_NO_PLT_LOCALENTRY }, 716 { "emit-stub-syms", no_argument, NULL, OPTION_STUBSYMS }, 717 { "no-emit-stub-syms", no_argument, NULL, OPTION_NO_STUBSYMS }, 718 { "dotsyms", no_argument, NULL, OPTION_DOTSYMS }, 719 { "no-dotsyms", no_argument, NULL, OPTION_NO_DOTSYMS }, 720 { "save-restore-funcs", no_argument, NULL, OPTION_SAVRES }, 721 { "no-save-restore-funcs", no_argument, NULL, OPTION_NO_SAVRES }, 722 { "no-tls-optimize", no_argument, NULL, OPTION_NO_TLS_OPT }, 723 { "tls-get-addr-optimize", no_argument, NULL, OPTION_TLS_GET_ADDR_OPT }, 724 { "no-tls-get-addr-optimize", no_argument, NULL, OPTION_NO_TLS_GET_ADDR_OPT }, 725 { "no-opd-optimize", no_argument, NULL, OPTION_NO_OPD_OPT }, 726 { "no-inline-optimize", no_argument, NULL, OPTION_NO_INLINE_OPT }, 727 { "no-toc-optimize", no_argument, NULL, OPTION_NO_TOC_OPT }, 728 { "no-multi-toc", no_argument, NULL, OPTION_NO_MULTI_TOC }, 729 { "no-toc-sort", no_argument, NULL, OPTION_NO_TOC_SORT }, 730 { "non-overlapping-opd", no_argument, NULL, OPTION_NON_OVERLAPPING_OPD }, 731' 732 733PARSE_AND_LIST_OPTIONS=${PARSE_AND_LIST_OPTIONS}' 734 fprintf (file, _("\ 735 --stub-group-size=N Maximum size of a group of input sections that\n\ 736 can be handled by one stub section. A negative\n\ 737 value locates all stubs before their branches\n\ 738 (with a group size of -N), while a positive\n\ 739 value allows two groups of input sections, one\n\ 740 before, and one after each stub section.\n\ 741 Values of +/-1 indicate the linker should\n\ 742 choose suitable defaults.\n" 743 )); 744 fprintf (file, _("\ 745 --plt-static-chain PLT call stubs should load r11'${DEFAULT_PLT_STATIC_CHAIN- (default)}'\n" 746 )); 747 fprintf (file, _("\ 748 --no-plt-static-chain PLT call stubs should not load r11'${DEFAULT_PLT_STATIC_CHAIN+ (default)}'\n" 749 )); 750 fprintf (file, _("\ 751 --plt-thread-safe PLT call stubs with load-load barrier\n" 752 )); 753 fprintf (file, _("\ 754 --no-plt-thread-safe PLT call stubs without barrier\n" 755 )); 756 fprintf (file, _("\ 757 --plt-align [=<align>] Align PLT call stubs to fit cache lines\n" 758 )); 759 fprintf (file, _("\ 760 --no-plt-align Dont'\''t align individual PLT call stubs\n" 761 )); 762 fprintf (file, _("\ 763 --plt-localentry Optimize calls to ELFv2 localentry:0 functions\n" 764 )); 765 fprintf (file, _("\ 766 --no-plt-localentry Don'\''t optimize ELFv2 calls\n" 767 )); 768 fprintf (file, _("\ 769 --emit-stub-syms Label linker stubs with a symbol\n" 770 )); 771 fprintf (file, _("\ 772 --no-emit-stub-syms Don'\''t label linker stubs with a symbol\n" 773 )); 774 fprintf (file, _("\ 775 --dotsyms For every version pattern \"foo\" in a version\n\ 776 script, add \".foo\" so that function code\n\ 777 symbols are treated the same as function\n\ 778 descriptor symbols. Defaults to on.\n" 779 )); 780 fprintf (file, _("\ 781 --no-dotsyms Don'\''t do anything special in version scripts\n" 782 )); 783 fprintf (file, _("\ 784 --save-restore-funcs Provide register save and restore routines used\n\ 785 by gcc -Os code. Defaults to on for normal\n\ 786 final link, off for ld -r.\n" 787 )); 788 fprintf (file, _("\ 789 --no-save-restore-funcs Don'\''t provide these routines\n" 790 )); 791 fprintf (file, _("\ 792 --no-tls-optimize Don'\''t try to optimize TLS accesses\n" 793 )); 794 fprintf (file, _("\ 795 --tls-get-addr-optimize Force use of special __tls_get_addr call\n" 796 )); 797 fprintf (file, _("\ 798 --no-tls-get-addr-optimize Don'\''t use a special __tls_get_addr call\n" 799 )); 800 fprintf (file, _("\ 801 --no-opd-optimize Don'\''t optimize the OPD section\n" 802 )); 803 fprintf (file, _("\ 804 --no-inline-optimize Don'\''t convert inline PLT to direct calls\n" 805 )); 806 fprintf (file, _("\ 807 --no-toc-optimize Don'\''t optimize the TOC section\n" 808 )); 809 fprintf (file, _("\ 810 --no-multi-toc Disallow automatic multiple toc sections\n" 811 )); 812 fprintf (file, _("\ 813 --no-toc-sort Don'\''t sort TOC and GOT sections\n" 814 )); 815 fprintf (file, _("\ 816 --non-overlapping-opd Canonicalize .opd, so that there are no\n\ 817 overlapping .opd entries\n" 818 )); 819' 820 821PARSE_AND_LIST_ARGS_CASES=${PARSE_AND_LIST_ARGS_CASES}' 822 case OPTION_STUBGROUP_SIZE: 823 { 824 const char *end; 825 params.group_size = bfd_scan_vma (optarg, &end, 0); 826 if (*end) 827 einfo (_("%F%P: invalid number `%s'\''\n"), optarg); 828 } 829 break; 830 831 case OPTION_PLT_STATIC_CHAIN: 832 params.plt_static_chain = 1; 833 break; 834 835 case OPTION_NO_PLT_STATIC_CHAIN: 836 params.plt_static_chain = 0; 837 break; 838 839 case OPTION_PLT_THREAD_SAFE: 840 params.plt_thread_safe = 1; 841 break; 842 843 case OPTION_NO_PLT_THREAD_SAFE: 844 params.plt_thread_safe = 0; 845 break; 846 847 case OPTION_PLT_ALIGN: 848 if (optarg != NULL) 849 { 850 char *end; 851 long val = strtol (optarg, &end, 0); 852 if (*end || (unsigned long) val + 8 > 16) 853 einfo (_("%F%P: invalid --plt-align `%s'\''\n"), optarg); 854 params.plt_stub_align = val; 855 } 856 else 857 params.plt_stub_align = 5; 858 break; 859 860 case OPTION_NO_PLT_ALIGN: 861 params.plt_stub_align = 0; 862 break; 863 864 case OPTION_PLT_LOCALENTRY: 865 params.plt_localentry0 = 1; 866 break; 867 868 case OPTION_NO_PLT_LOCALENTRY: 869 params.plt_localentry0 = 0; 870 break; 871 872 case OPTION_STUBSYMS: 873 params.emit_stub_syms = 1; 874 break; 875 876 case OPTION_NO_STUBSYMS: 877 params.emit_stub_syms = 0; 878 break; 879 880 case OPTION_DOTSYMS: 881 dotsyms = 1; 882 break; 883 884 case OPTION_NO_DOTSYMS: 885 dotsyms = 0; 886 break; 887 888 case OPTION_SAVRES: 889 params.save_restore_funcs = 1; 890 break; 891 892 case OPTION_NO_SAVRES: 893 params.save_restore_funcs = 0; 894 break; 895 896 case OPTION_NO_TLS_OPT: 897 no_tls_opt = 1; 898 break; 899 900 case OPTION_TLS_GET_ADDR_OPT: 901 params.tls_get_addr_opt = 1; 902 break; 903 904 case OPTION_NO_TLS_GET_ADDR_OPT: 905 params.tls_get_addr_opt = 0; 906 break; 907 908 case OPTION_NO_OPD_OPT: 909 no_opd_opt = 1; 910 break; 911 912 case OPTION_NO_INLINE_OPT: 913 no_inline_opt = 1; 914 break; 915 916 case OPTION_NO_TOC_OPT: 917 no_toc_opt = 1; 918 break; 919 920 case OPTION_NO_MULTI_TOC: 921 params.no_multi_toc = 1; 922 break; 923 924 case OPTION_NO_TOC_SORT: 925 no_toc_sort = 1; 926 break; 927 928 case OPTION_NON_OVERLAPPING_OPD: 929 params.non_overlapping_opd = 1; 930 break; 931 932 case OPTION_TRADITIONAL_FORMAT: 933 no_tls_opt = 1; 934 params.tls_get_addr_opt = 0; 935 no_opd_opt = 1; 936 no_toc_opt = 1; 937 params.no_multi_toc = 1; 938 no_toc_sort = 1; 939 params.plt_static_chain = 1; 940 return FALSE; 941' 942 943# Put these extra ppc64elf routines in ld_${EMULATION_NAME}_emulation 944# 945LDEMUL_NEW_VERS_PATTERN=gld${EMULATION_NAME}_new_vers_pattern 946LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS=ppc_create_output_section_statements 947LDEMUL_AFTER_OPEN=ppc_after_open 948LDEMUL_BEFORE_ALLOCATION=ppc_before_allocation 949LDEMUL_AFTER_ALLOCATION=gld${EMULATION_NAME}_after_allocation 950LDEMUL_FINISH=gld${EMULATION_NAME}_finish 951