ld/emultempl/ppc64elf.em

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