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
  33 static asection *ppc_add_stub_section (const char *, asection *);
  34 static void ppc_layout_sections_again (void);
  35
  36 static struct ppc64_elf_params params = { NULL,
  37                                           &ppc_add_stub_section,
  38                                           &ppc_layout_sections_again,
  39                                           1, 0, 0,
  40                                           ${DEFAULT_PLT_STATIC_CHAIN-0}, -1, 0,
  41                                           0, -1, -1};
  42
  43 /* Fake input file for stubs.  */
  44 static lang_input_statement_type *stub_file;
  45 static int stub_added = 0;
  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   stub_added = 1;
 394   if (hook_in_stub (&info, &os->children.head))
 395     return stub_sec;
 396
 397  err_ret:
 398   einfo ("%X%P: can not make stub section: %E\n");
 399   return NULL;
 400 }
 401
 402
 403 /* Another call-back for ppc64_elf_size_stubs.  */
 404
 405 static void
 406 ppc_layout_sections_again (void)
 407 {
 408   /* If we have changed sizes of the stub sections, then we need
 409      to recalculate all the section offsets.  This may mean we need to
 410      add even more stubs.  */
 411   gld${EMULATION_NAME}_map_segments (TRUE);
 412
 413   if (!link_info.relocatable)
 414     ppc64_elf_set_toc (&link_info, link_info.output_bfd);
 415
 416   need_laying_out = -1;
 417 }
 418
 419
 420 static void
 421 build_toc_list (lang_statement_union_type *statement)
 422 {
 423   if (statement->header.type == lang_input_section_enum)
 424     {
 425       asection *i = statement->input_section.section;
 426
 427       if (i->sec_info_type != SEC_INFO_TYPE_JUST_SYMS
 428           && (i->flags & SEC_EXCLUDE) == 0
 429           && i->output_section == toc_section)
 430         {
 431           if (!ppc64_elf_next_toc_section (&link_info, i))
 432             einfo ("%X%P: linker script separates .got and .toc\n");
 433         }
 434     }
 435 }
 436
 437
 438 static void
 439 build_section_lists (lang_statement_union_type *statement)
 440 {
 441   if (statement->header.type == lang_input_section_enum)
 442     {
 443       asection *i = statement->input_section.section;
 444
 445       if (!((lang_input_statement_type *) i->owner->usrdata)->flags.just_syms
 446           && (i->flags & SEC_EXCLUDE) == 0
 447           && i->output_section != NULL
 448           && i->output_section->owner == link_info.output_bfd)
 449         {
 450           if (!ppc64_elf_next_input_section (&link_info, i))
 451             einfo ("%X%P: can not size stub section: %E\n");
 452         }
 453     }
 454 }
 455
 456
 457 /* Call the back-end function to set TOC base after we have placed all
 458    the sections.  */
 459 static void
 460 gld${EMULATION_NAME}_after_allocation (void)
 461 {
 462   /* bfd_elf_discard_info just plays with data and debugging sections,
 463      ie. doesn't affect code size, so we can delay resizing the
 464      sections.  It's likely we'll resize everything in the process of
 465      adding stubs.  */
 466   if (bfd_elf_discard_info (link_info.output_bfd, &link_info))
 467     need_laying_out = 1;
 468
 469   /* If generating a relocatable output file, then we don't have any
 470      stubs.  */
 471   if (stub_file != NULL && !link_info.relocatable)
 472     {
 473       int ret = ppc64_elf_setup_section_lists (&link_info);
 474       if (ret < 0)
 475         einfo ("%X%P: can not size stub section: %E\n");
 476       else if (ret > 0)
 477         {
 478           ppc64_elf_start_multitoc_partition (&link_info);
 479
 480           if (!params.no_multi_toc)
 481             {
 482               toc_section = bfd_get_section_by_name (link_info.output_bfd,
 483                                                      ".got");
 484               if (toc_section != NULL)
 485                 lang_for_each_statement (build_toc_list);
 486             }
 487
 488           if (ppc64_elf_layout_multitoc (&link_info)
 489               && !params.no_multi_toc
 490               && toc_section != NULL)
 491             lang_for_each_statement (build_toc_list);
 492
 493           ppc64_elf_finish_multitoc_partition (&link_info);
 494
 495           lang_for_each_statement (build_section_lists);
 496
 497           if (!ppc64_elf_check_init_fini (&link_info))
 498             einfo ("%P: .init/.fini fragments use differing TOC pointers\n");
 499
 500           /* Call into the BFD backend to do the real work.  */
 501           if (!ppc64_elf_size_stubs (&link_info))
 502             einfo ("%X%P: can not size stub section: %E\n");
 503         }
 504     }
 505
 506   if (need_laying_out != -1)
 507     {
 508       gld${EMULATION_NAME}_map_segments (need_laying_out);
 509
 510       if (!link_info.relocatable)
 511         ppc64_elf_set_toc (&link_info, link_info.output_bfd);
 512     }
 513 }
 514
 515
 516 /* Final emulation specific call.  */
 517
 518 static void
 519 gld${EMULATION_NAME}_finish (void)
 520 {
 521   /* e_entry on PowerPC64 points to the function descriptor for
 522      _start.  If _start is missing, default to the first function
 523      descriptor in the .opd section.  */
 524   entry_section = ".opd";
 525
 526   if (stub_added)
 527     {
 528       char *msg = NULL;
 529       char *line, *endline;
 530
 531       if (params.emit_stub_syms < 0)
 532         params.emit_stub_syms = 1;
 533       if (!ppc64_elf_build_stubs (&link_info, config.stats ? &msg : NULL))
 534         einfo ("%X%P: can not build stubs: %E\n");
 535
 536       fflush (stdout);
 537       for (line = msg; line != NULL; line = endline)
 538         {
 539           endline = strchr (line, '\n');
 540           if (endline != NULL)
 541             *endline++ = '\0';
 542           fprintf (stderr, "%s: %s\n", program_name, line);
 543         }
 544       fflush (stderr);
 545       if (msg != NULL)
 546         free (msg);
 547     }
 548
 549   ppc64_elf_restore_symbols (&link_info);
 550   finish_default ();
 551 }
 552
 553
 554 /* Add a pattern matching ".foo" for every "foo" in a version script.
 555
 556    The reason for doing this is that many shared library version
 557    scripts export a selected set of functions or data symbols, forcing
 558    others local.  eg.
 559
 560    . VERS_1 {
 561    .       global:
 562    .               this; that; some; thing;
 563    .       local:
 564    .               *;
 565    .   };
 566
 567    To make the above work for PowerPC64, we need to export ".this",
 568    ".that" and so on, otherwise only the function descriptor syms are
 569    exported.  Lack of an exported function code sym may cause a
 570    definition to be pulled in from a static library.  */
 571
 572 static struct bfd_elf_version_expr *
 573 gld${EMULATION_NAME}_new_vers_pattern (struct bfd_elf_version_expr *entry)
 574 {
 575   struct bfd_elf_version_expr *dot_entry;
 576   unsigned int len;
 577   char *dot_pat;
 578
 579   if (!dotsyms
 580       || entry->pattern[0] == '.'
 581       || (!entry->literal && entry->pattern[0] == '*'))
 582     return entry;
 583
 584   dot_entry = xmalloc (sizeof *dot_entry);
 585   *dot_entry = *entry;
 586   dot_entry->next = entry;
 587   len = strlen (entry->pattern) + 2;
 588   dot_pat = xmalloc (len);
 589   dot_pat[0] = '.';
 590   memcpy (dot_pat + 1, entry->pattern, len - 1);
 591   dot_entry->pattern = dot_pat;
 592   dot_entry->script = 1;
 593   return dot_entry;
 594 }
 595
 596
 597 /* Avoid processing the fake stub_file in vercheck, stat_needed and
 598    check_needed routines.  */
 599
 600 static void (*real_func) (lang_input_statement_type *);
 601
 602 static void ppc_for_each_input_file_wrapper (lang_input_statement_type *l)
 603 {
 604   if (l != stub_file)
 605     (*real_func) (l);
 606 }
 607
 608 static void
 609 ppc_lang_for_each_input_file (void (*func) (lang_input_statement_type *))
 610 {
 611   real_func = func;
 612   lang_for_each_input_file (&ppc_for_each_input_file_wrapper);
 613 }
 614
 615 #define lang_for_each_input_file ppc_lang_for_each_input_file
 616
 617 EOF
 618
 619 if grep -q 'ld_elf32_spu_emulation' ldemul-list.h; then
 620   fragment <<EOF
 621 /* Special handling for embedded SPU executables.  */
 622 extern bfd_boolean embedded_spu_file (lang_input_statement_type *, const char *);
 623 static bfd_boolean gld${EMULATION_NAME}_load_symbols (lang_input_statement_type *);
 624
 625 static bfd_boolean
 626 ppc64_recognized_file (lang_input_statement_type *entry)
 627 {
 628   if (embedded_spu_file (entry, "-m64"))
 629     return TRUE;
 630
 631   return gld${EMULATION_NAME}_load_symbols (entry);
 632 }
 633 EOF
 634 LDEMUL_RECOGNIZED_FILE=ppc64_recognized_file
 635 fi
 636
 637 # Define some shell vars to insert bits of code into the standard elf
 638 # parse_args and list_options functions.
 639 #
 640 PARSE_AND_LIST_PROLOGUE=${PARSE_AND_LIST_PROLOGUE}'
 641 #define OPTION_STUBGROUP_SIZE           321
 642 #define OPTION_PLT_STATIC_CHAIN         (OPTION_STUBGROUP_SIZE + 1)
 643 #define OPTION_NO_PLT_STATIC_CHAIN      (OPTION_PLT_STATIC_CHAIN + 1)
 644 #define OPTION_PLT_THREAD_SAFE          (OPTION_NO_PLT_STATIC_CHAIN + 1)
 645 #define OPTION_NO_PLT_THREAD_SAFE       (OPTION_PLT_THREAD_SAFE + 1)
 646 #define OPTION_PLT_ALIGN                (OPTION_NO_PLT_THREAD_SAFE + 1)
 647 #define OPTION_NO_PLT_ALIGN             (OPTION_PLT_ALIGN + 1)
 648 #define OPTION_STUBSYMS                 (OPTION_NO_PLT_ALIGN + 1)
 649 #define OPTION_NO_STUBSYMS              (OPTION_STUBSYMS + 1)
 650 #define OPTION_SAVRES                   (OPTION_NO_STUBSYMS + 1)
 651 #define OPTION_NO_SAVRES                (OPTION_SAVRES + 1)
 652 #define OPTION_DOTSYMS                  (OPTION_NO_SAVRES + 1)
 653 #define OPTION_NO_DOTSYMS               (OPTION_DOTSYMS + 1)
 654 #define OPTION_NO_TLS_OPT               (OPTION_NO_DOTSYMS + 1)
 655 #define OPTION_NO_TLS_GET_ADDR_OPT      (OPTION_NO_TLS_OPT + 1)
 656 #define OPTION_NO_OPD_OPT               (OPTION_NO_TLS_GET_ADDR_OPT + 1)
 657 #define OPTION_NO_TOC_OPT               (OPTION_NO_OPD_OPT + 1)
 658 #define OPTION_NO_MULTI_TOC             (OPTION_NO_TOC_OPT + 1)
 659 #define OPTION_NO_TOC_SORT              (OPTION_NO_MULTI_TOC + 1)
 660 #define OPTION_NON_OVERLAPPING_OPD      (OPTION_NO_TOC_SORT + 1)
 661 '
 662
 663 PARSE_AND_LIST_LONGOPTS=${PARSE_AND_LIST_LONGOPTS}'
 664   { "stub-group-size", required_argument, NULL, OPTION_STUBGROUP_SIZE },
 665   { "plt-static-chain", no_argument, NULL, OPTION_PLT_STATIC_CHAIN },
 666   { "no-plt-static-chain", no_argument, NULL, OPTION_NO_PLT_STATIC_CHAIN },
 667   { "plt-thread-safe", no_argument, NULL, OPTION_PLT_THREAD_SAFE },
 668   { "no-plt-thread-safe", no_argument, NULL, OPTION_NO_PLT_THREAD_SAFE },
 669   { "plt-align", optional_argument, NULL, OPTION_PLT_ALIGN },
 670   { "no-plt-align", no_argument, NULL, OPTION_NO_PLT_ALIGN },
 671   { "emit-stub-syms", no_argument, NULL, OPTION_STUBSYMS },
 672   { "no-emit-stub-syms", no_argument, NULL, OPTION_NO_STUBSYMS },
 673   { "dotsyms", no_argument, NULL, OPTION_DOTSYMS },
 674   { "no-dotsyms", no_argument, NULL, OPTION_NO_DOTSYMS },
 675   { "save-restore-funcs", no_argument, NULL, OPTION_SAVRES },
 676   { "no-save-restore-funcs", no_argument, NULL, OPTION_NO_SAVRES },
 677   { "no-tls-optimize", no_argument, NULL, OPTION_NO_TLS_OPT },
 678   { "no-tls-get-addr-optimize", no_argument, NULL, OPTION_NO_TLS_GET_ADDR_OPT },
 679   { "no-opd-optimize", no_argument, NULL, OPTION_NO_OPD_OPT },
 680   { "no-toc-optimize", no_argument, NULL, OPTION_NO_TOC_OPT },
 681   { "no-multi-toc", no_argument, NULL, OPTION_NO_MULTI_TOC },
 682   { "no-toc-sort", no_argument, NULL, OPTION_NO_TOC_SORT },
 683   { "non-overlapping-opd", no_argument, NULL, OPTION_NON_OVERLAPPING_OPD },
 684 '
 685
 686 PARSE_AND_LIST_OPTIONS=${PARSE_AND_LIST_OPTIONS}'
 687   fprintf (file, _("\
 688   --stub-group-size=N         Maximum size of a group of input sections that\n\
 689                                 can be handled by one stub section.  A negative\n\
 690                                 value locates all stubs before their branches\n\
 691                                 (with a group size of -N), while a positive\n\
 692                                 value allows two groups of input sections, one\n\
 693                                 before, and one after each stub section.\n\
 694                                 Values of +/-1 indicate the linker should\n\
 695                                 choose suitable defaults.\n"
 696                    ));
 697   fprintf (file, _("\
 698   --plt-static-chain          PLT call stubs should load r11.${DEFAULT_PLT_STATIC_CHAIN- (default)}\n"
 699                    ));
 700   fprintf (file, _("\
 701   --no-plt-static-chain       PLT call stubs should not load r11.${DEFAULT_PLT_STATIC_CHAIN+ (default)}\n"
 702                    ));
 703   fprintf (file, _("\
 704   --plt-thread-safe           PLT call stubs with load-load barrier.\n"
 705                    ));
 706   fprintf (file, _("\
 707   --no-plt-thread-safe        PLT call stubs without barrier.\n"
 708                    ));
 709   fprintf (file, _("\
 710   --plt-align [=<align>]      Align PLT call stubs to fit cache lines.\n"
 711                    ));
 712   fprintf (file, _("\
 713   --no-plt-align              Dont'\''t align individual PLT call stubs.\n"
 714                    ));
 715   fprintf (file, _("\
 716   --emit-stub-syms            Label linker stubs with a symbol.\n"
 717                    ));
 718   fprintf (file, _("\
 719   --no-emit-stub-syms         Don'\''t label linker stubs with a symbol.\n"
 720                    ));
 721   fprintf (file, _("\
 722   --dotsyms                   For every version pattern \"foo\" in a version\n\
 723                                 script, add \".foo\" so that function code\n\
 724                                 symbols are treated the same as function\n\
 725                                 descriptor symbols.  Defaults to on.\n"
 726                    ));
 727   fprintf (file, _("\
 728   --no-dotsyms                Don'\''t do anything special in version scripts.\n"
 729                    ));
 730   fprintf (file, _("\
 731   --save-restore-funcs        Provide register save and restore routines used\n\
 732                                 by gcc -Os code.  Defaults to on for normal\n\
 733                                 final link, off for ld -r.\n"
 734                    ));
 735   fprintf (file, _("\
 736   --no-save-restore-funcs     Don'\''t provide these routines.\n"
 737                    ));
 738   fprintf (file, _("\
 739   --no-tls-optimize           Don'\''t try to optimize TLS accesses.\n"
 740                    ));
 741   fprintf (file, _("\
 742   --no-tls-get-addr-optimize  Don'\''t use a special __tls_get_addr call.\n"
 743                    ));
 744   fprintf (file, _("\
 745   --no-opd-optimize           Don'\''t optimize the OPD section.\n"
 746                    ));
 747   fprintf (file, _("\
 748   --no-toc-optimize           Don'\''t optimize the TOC section.\n"
 749                    ));
 750   fprintf (file, _("\
 751   --no-multi-toc              Disallow automatic multiple toc sections.\n"
 752                    ));
 753   fprintf (file, _("\
 754   --no-toc-sort               Don'\''t sort TOC and GOT sections.\n"
 755                    ));
 756   fprintf (file, _("\
 757   --non-overlapping-opd       Canonicalize .opd, so that there are no\n\
 758                                 overlapping .opd entries.\n"
 759                    ));
 760 '
 761
 762 PARSE_AND_LIST_ARGS_CASES=${PARSE_AND_LIST_ARGS_CASES}'
 763     case OPTION_STUBGROUP_SIZE:
 764       {
 765         const char *end;
 766         params.group_size = bfd_scan_vma (optarg, &end, 0);
 767         if (*end)
 768           einfo (_("%P%F: invalid number `%s'\''\n"), optarg);
 769       }
 770       break;
 771
 772     case OPTION_PLT_STATIC_CHAIN:
 773       params.plt_static_chain = 1;
 774       break;
 775
 776     case OPTION_NO_PLT_STATIC_CHAIN:
 777       params.plt_static_chain = 0;
 778       break;
 779
 780     case OPTION_PLT_THREAD_SAFE:
 781       params.plt_thread_safe = 1;
 782       break;
 783
 784     case OPTION_NO_PLT_THREAD_SAFE:
 785       params.plt_thread_safe = 0;
 786       break;
 787
 788     case OPTION_PLT_ALIGN:
 789       if (optarg != NULL)
 790         {
 791           char *end;
 792           unsigned long val = strtoul (optarg, &end, 0);
 793           if (*end || val > 8)
 794             einfo (_("%P%F: invalid --plt-align `%s'\''\n"), optarg);
 795           plt_stub_align = val;
 796         }
 797       else
 798         plt_stub_align = 5;
 799       break;
 800
 801     case OPTION_NO_PLT_ALIGN:
 802       plt_stub_align = 0;
 803       break;
 804
 805     case OPTION_STUBSYMS:
 806       params.emit_stub_syms = 1;
 807       break;
 808
 809     case OPTION_NO_STUBSYMS:
 810       params.emit_stub_syms = 0;
 811       break;
 812
 813     case OPTION_DOTSYMS:
 814       dotsyms = 1;
 815       break;
 816
 817     case OPTION_NO_DOTSYMS:
 818       dotsyms = 0;
 819       break;
 820
 821     case OPTION_SAVRES:
 822       params.save_restore_funcs = 1;
 823       break;
 824
 825     case OPTION_NO_SAVRES:
 826       params.save_restore_funcs = 0;
 827       break;
 828
 829     case OPTION_NO_TLS_OPT:
 830       no_tls_opt = 1;
 831       break;
 832
 833     case OPTION_NO_TLS_GET_ADDR_OPT:
 834       params.no_tls_get_addr_opt = 1;
 835       break;
 836
 837     case OPTION_NO_OPD_OPT:
 838       no_opd_opt = 1;
 839       break;
 840
 841     case OPTION_NO_TOC_OPT:
 842       no_toc_opt = 1;
 843       break;
 844
 845     case OPTION_NO_MULTI_TOC:
 846       params.no_multi_toc = 1;
 847       break;
 848
 849     case OPTION_NO_TOC_SORT:
 850       no_toc_sort = 1;
 851       break;
 852
 853     case OPTION_NON_OVERLAPPING_OPD:
 854       params.non_overlapping_opd = 1;
 855       break;
 856
 857     case OPTION_TRADITIONAL_FORMAT:
 858       no_tls_opt = 1;
 859       params.no_tls_get_addr_opt = 1;
 860       no_opd_opt = 1;
 861       no_toc_opt = 1;
 862       params.no_multi_toc = 1;
 863       no_toc_sort = 1;
 864       params.plt_static_chain = 1;
 865       return FALSE;
 866 '
 867
 868 # Put these extra ppc64elf routines in ld_${EMULATION_NAME}_emulation
 869 #
 870 LDEMUL_BEFORE_ALLOCATION=ppc_before_allocation
 871 LDEMUL_AFTER_ALLOCATION=gld${EMULATION_NAME}_after_allocation
 872 LDEMUL_FINISH=gld${EMULATION_NAME}_finish
 873 LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS=ppc_create_output_section_statements
 874 LDEMUL_NEW_VERS_PATTERN=gld${EMULATION_NAME}_new_vers_pattern