ld/emultempl/ppc64elf.em

   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, &params))
 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