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