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