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