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