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