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