ld/emultempl/ppc64elf.em

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