ld/emultempl/ppc64elf.em

   1 # This shell script emits a C file. -*- C -*-
   2 # Copyright (C) 2002-2018 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, 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_seg_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                                       : params.plt_stub_align < -5
 416                                       ? -params.plt_stub_align
 417                                       : 5)))
 418     goto err_ret;
 419
 420   output_section = input_section->output_section;
 421   os = lang_output_section_get (output_section);
 422
 423   info.input_section = input_section;
 424   lang_list_init (&info.add);
 425   lang_add_section (&info.add, stub_sec, NULL, os);
 426
 427   if (info.add.head == NULL)
 428     goto err_ret;
 429
 430   if (hook_in_stub (&info, &os->children.head))
 431     return stub_sec;
 432
 433  err_ret:
 434   einfo (_("%X%P: can not make stub section: %E\n"));
 435   return NULL;
 436 }
 437
 438
 439 /* Another call-back for ppc64_elf_size_stubs.  */
 440
 441 static void
 442 ppc_layout_sections_again (void)
 443 {
 444   /* If we have changed sizes of the stub sections, then we need
 445      to recalculate all the section offsets.  This may mean we need to
 446      add even more stubs.  */
 447   gld${EMULATION_NAME}_map_segments (TRUE);
 448
 449   if (!bfd_link_relocatable (&link_info))
 450     ppc64_elf_set_toc (&link_info, link_info.output_bfd);
 451
 452   need_laying_out = -1;
 453 }
 454
 455
 456 static void
 457 build_toc_list (lang_statement_union_type *statement)
 458 {
 459   if (statement->header.type == lang_input_section_enum)
 460     {
 461       asection *i = statement->input_section.section;
 462
 463       if (i->sec_info_type != SEC_INFO_TYPE_JUST_SYMS
 464           && (i->flags & SEC_EXCLUDE) == 0
 465           && i->output_section == toc_section)
 466         {
 467           if (!ppc64_elf_next_toc_section (&link_info, i))
 468             einfo (_("%X%P: linker script separates .got and .toc\n"));
 469         }
 470     }
 471 }
 472
 473
 474 static void
 475 build_section_lists (lang_statement_union_type *statement)
 476 {
 477   if (statement->header.type == lang_input_section_enum)
 478     {
 479       asection *i = statement->input_section.section;
 480
 481       if (!((lang_input_statement_type *) i->owner->usrdata)->flags.just_syms
 482           && (i->flags & SEC_EXCLUDE) == 0
 483           && i->output_section != NULL
 484           && i->output_section->owner == link_info.output_bfd)
 485         {
 486           if (!ppc64_elf_next_input_section (&link_info, i))
 487             einfo (_("%X%P: can not size stub section: %E\n"));
 488         }
 489     }
 490 }
 491
 492
 493 /* Call the back-end function to set TOC base after we have placed all
 494    the sections.  */
 495 static void
 496 gld${EMULATION_NAME}_after_allocation (void)
 497 {
 498   int ret;
 499
 500   /* If generating a relocatable output file, then we don't have any
 501      stubs.  */
 502   if (stub_file != NULL && !bfd_link_relocatable (&link_info))
 503     {
 504       ret = ppc64_elf_setup_section_lists (&link_info);
 505       if (ret < 0)
 506         einfo (_("%X%P: can not size stub section: %E\n"));
 507       else
 508         {
 509           ppc64_elf_start_multitoc_partition (&link_info);
 510
 511           if (!params.no_multi_toc)
 512             {
 513               toc_section = bfd_get_section_by_name (link_info.output_bfd,
 514                                                      toc_section_name);
 515               if (toc_section != NULL)
 516                 lang_for_each_statement (build_toc_list);
 517             }
 518
 519           if (ppc64_elf_layout_multitoc (&link_info)
 520               && !params.no_multi_toc
 521               && toc_section != NULL)
 522             lang_for_each_statement (build_toc_list);
 523
 524           ppc64_elf_finish_multitoc_partition (&link_info);
 525
 526           lang_for_each_statement (build_section_lists);
 527
 528           if (!ppc64_elf_check_init_fini (&link_info))
 529             einfo (_("%P: .init/.fini fragments use differing TOC pointers\n"));
 530
 531           /* Call into the BFD backend to do the real work.  */
 532           if (!ppc64_elf_size_stubs (&link_info))
 533             einfo (_("%X%P: can not size stub section: %E\n"));
 534         }
 535     }
 536
 537   /* We can't parse and merge .eh_frame until the glink .eh_frame has
 538      been generated.  Otherwise the glink .eh_frame CIE won't be
 539      merged with other CIEs, and worse, the glink .eh_frame FDEs won't
 540      be listed in .eh_frame_hdr.  */
 541   ret = bfd_elf_discard_info (link_info.output_bfd, &link_info);
 542   if (ret < 0)
 543     {
 544       einfo (_("%X%P: .eh_frame/.stab edit: %E\n"));
 545       return;
 546     }
 547   else if (ret > 0)
 548     need_laying_out = 1;
 549
 550   /* Call map_segments regardless of the state of need_laying_out.
 551      need_laying_out set to -1 means we have just laid everything out,
 552      but ppc64_elf_size_stubs strips .branch_lt and .eh_frame if
 553      unneeded, after ppc_layout_sections_again.  Another call removes
 554      these sections from the segment map.  Their presence is
 555      innocuous except for confusing ELF_SECTION_IN_SEGMENT.  */
 556   gld${EMULATION_NAME}_map_segments (need_laying_out > 0);
 557
 558   if (need_laying_out != -1 && !bfd_link_relocatable (&link_info))
 559     ppc64_elf_set_toc (&link_info, link_info.output_bfd);
 560 }
 561
 562
 563 /* Final emulation specific call.  */
 564
 565 static void
 566 gld${EMULATION_NAME}_finish (void)
 567 {
 568   char *msg = NULL;
 569   char *line, *endline;
 570
 571   /* e_entry on PowerPC64 points to the function descriptor for
 572      _start.  If _start is missing, default to the first function
 573      descriptor in the .opd section.  */
 574   if (stub_file != NULL
 575       && (elf_elfheader (link_info.output_bfd)->e_flags & EF_PPC64_ABI) == 1)
 576     entry_section = ".opd";
 577
 578   if (params.emit_stub_syms < 0)
 579     params.emit_stub_syms = 1;
 580   if (stub_file != NULL
 581       && !bfd_link_relocatable (&link_info)
 582       && !ppc64_elf_build_stubs (&link_info, config.stats ? &msg : NULL))
 583     einfo (_("%X%P: can not build stubs: %E\n"));
 584
 585   fflush (stdout);
 586   for (line = msg; line != NULL; line = endline)
 587     {
 588       endline = strchr (line, '\n');
 589       if (endline != NULL)
 590         *endline++ = '\0';
 591       fprintf (stderr, "%s: %s\n", program_name, line);
 592     }
 593   fflush (stderr);
 594   if (msg != NULL)
 595     free (msg);
 596
 597   finish_default ();
 598 }
 599
 600
 601 /* Add a pattern matching ".foo" for every "foo" in a version script.
 602
 603    The reason for doing this is that many shared library version
 604    scripts export a selected set of functions or data symbols, forcing
 605    others local.  eg.
 606
 607    . VERS_1 {
 608    .       global:
 609    .               this; that; some; thing;
 610    .       local:
 611    .               *;
 612    .   };
 613
 614    To make the above work for PowerPC64, we need to export ".this",
 615    ".that" and so on, otherwise only the function descriptor syms are
 616    exported.  Lack of an exported function code sym may cause a
 617    definition to be pulled in from a static library.  */
 618
 619 static struct bfd_elf_version_expr *
 620 gld${EMULATION_NAME}_new_vers_pattern (struct bfd_elf_version_expr *entry)
 621 {
 622   struct bfd_elf_version_expr *dot_entry;
 623   unsigned int len;
 624   char *dot_pat;
 625
 626   if (!dotsyms
 627       || entry->pattern[0] == '.'
 628       || (!entry->literal && entry->pattern[0] == '*'))
 629     return entry;
 630
 631   dot_entry = xmalloc (sizeof *dot_entry);
 632   *dot_entry = *entry;
 633   dot_entry->next = entry;
 634   len = strlen (entry->pattern) + 2;
 635   dot_pat = xmalloc (len);
 636   dot_pat[0] = '.';
 637   memcpy (dot_pat + 1, entry->pattern, len - 1);
 638   dot_entry->pattern = dot_pat;
 639   dot_entry->script = 1;
 640   return dot_entry;
 641 }
 642
 643
 644 /* Avoid processing the fake stub_file in vercheck, stat_needed and
 645    check_needed routines.  */
 646
 647 static void (*real_func) (lang_input_statement_type *);
 648
 649 static void ppc_for_each_input_file_wrapper (lang_input_statement_type *l)
 650 {
 651   if (l != stub_file)
 652     (*real_func) (l);
 653 }
 654
 655 static void
 656 ppc_lang_for_each_input_file (void (*func) (lang_input_statement_type *))
 657 {
 658   real_func = func;
 659   lang_for_each_input_file (&ppc_for_each_input_file_wrapper);
 660 }
 661
 662 #define lang_for_each_input_file ppc_lang_for_each_input_file
 663
 664 EOF
 665
 666 if grep -q 'ld_elf32_spu_emulation' ldemul-list.h; then
 667   fragment <<EOF
 668 /* Special handling for embedded SPU executables.  */
 669 extern bfd_boolean embedded_spu_file (lang_input_statement_type *, const char *);
 670 static bfd_boolean gld${EMULATION_NAME}_load_symbols (lang_input_statement_type *);
 671
 672 static bfd_boolean
 673 ppc64_recognized_file (lang_input_statement_type *entry)
 674 {
 675   if (embedded_spu_file (entry, "-m64"))
 676     return TRUE;
 677
 678   return gld${EMULATION_NAME}_load_symbols (entry);
 679 }
 680 EOF
 681 LDEMUL_RECOGNIZED_FILE=ppc64_recognized_file
 682 fi
 683
 684 # Define some shell vars to insert bits of code into the standard elf
 685 # parse_args and list_options functions.
 686 #
 687 PARSE_AND_LIST_PROLOGUE=${PARSE_AND_LIST_PROLOGUE}'
 688 enum ppc64_opt
 689 {
 690   OPTION_STUBGROUP_SIZE = 321,
 691   OPTION_PLT_STATIC_CHAIN,
 692   OPTION_NO_PLT_STATIC_CHAIN,
 693   OPTION_PLT_THREAD_SAFE,
 694   OPTION_NO_PLT_THREAD_SAFE,
 695   OPTION_SPECULATE_INDIRECT_JUMPS,
 696   OPTION_NO_SPECULATE_INDIRECT_JUMPS,
 697   OPTION_PLT_ALIGN,
 698   OPTION_NO_PLT_ALIGN,
 699   OPTION_PLT_LOCALENTRY,
 700   OPTION_NO_PLT_LOCALENTRY,
 701   OPTION_STUBSYMS,
 702   OPTION_NO_STUBSYMS,
 703   OPTION_SAVRES,
 704   OPTION_NO_SAVRES,
 705   OPTION_DOTSYMS,
 706   OPTION_NO_DOTSYMS,
 707   OPTION_NO_TLS_OPT,
 708   OPTION_TLS_GET_ADDR_OPT,
 709   OPTION_NO_TLS_GET_ADDR_OPT,
 710   OPTION_NO_OPD_OPT,
 711   OPTION_NO_TOC_OPT,
 712   OPTION_NO_MULTI_TOC,
 713   OPTION_NO_TOC_SORT,
 714   OPTION_NON_OVERLAPPING_OPD
 715 };
 716 '
 717
 718 PARSE_AND_LIST_LONGOPTS=${PARSE_AND_LIST_LONGOPTS}'
 719   { "stub-group-size", required_argument, NULL, OPTION_STUBGROUP_SIZE },
 720   { "plt-static-chain", no_argument, NULL, OPTION_PLT_STATIC_CHAIN },
 721   { "no-plt-static-chain", no_argument, NULL, OPTION_NO_PLT_STATIC_CHAIN },
 722   { "plt-thread-safe", no_argument, NULL, OPTION_PLT_THREAD_SAFE },
 723   { "no-plt-thread-safe", no_argument, NULL, OPTION_NO_PLT_THREAD_SAFE },
 724   { "speculate-indirect-jumps", no_argument, NULL, OPTION_SPECULATE_INDIRECT_JUMPS },
 725   { "no-speculate-indirect-jumps", no_argument, NULL, OPTION_NO_SPECULATE_INDIRECT_JUMPS },
 726   { "plt-align", optional_argument, NULL, OPTION_PLT_ALIGN },
 727   { "no-plt-align", no_argument, NULL, OPTION_NO_PLT_ALIGN },
 728   { "plt-localentry", optional_argument, NULL, OPTION_PLT_LOCALENTRY },
 729   { "no-plt-localentry", no_argument, NULL, OPTION_NO_PLT_LOCALENTRY },
 730   { "emit-stub-syms", no_argument, NULL, OPTION_STUBSYMS },
 731   { "no-emit-stub-syms", no_argument, NULL, OPTION_NO_STUBSYMS },
 732   { "dotsyms", no_argument, NULL, OPTION_DOTSYMS },
 733   { "no-dotsyms", no_argument, NULL, OPTION_NO_DOTSYMS },
 734   { "save-restore-funcs", no_argument, NULL, OPTION_SAVRES },
 735   { "no-save-restore-funcs", no_argument, NULL, OPTION_NO_SAVRES },
 736   { "no-tls-optimize", no_argument, NULL, OPTION_NO_TLS_OPT },
 737   { "tls-get-addr-optimize", no_argument, NULL, OPTION_TLS_GET_ADDR_OPT },
 738   { "no-tls-get-addr-optimize", no_argument, NULL, OPTION_NO_TLS_GET_ADDR_OPT },
 739   { "no-opd-optimize", no_argument, NULL, OPTION_NO_OPD_OPT },
 740   { "no-toc-optimize", no_argument, NULL, OPTION_NO_TOC_OPT },
 741   { "no-multi-toc", no_argument, NULL, OPTION_NO_MULTI_TOC },
 742   { "no-toc-sort", no_argument, NULL, OPTION_NO_TOC_SORT },
 743   { "non-overlapping-opd", no_argument, NULL, OPTION_NON_OVERLAPPING_OPD },
 744 '
 745
 746 PARSE_AND_LIST_OPTIONS=${PARSE_AND_LIST_OPTIONS}'
 747   fprintf (file, _("\
 748   --stub-group-size=N         Maximum size of a group of input sections that\n\
 749                                 can be handled by one stub section.  A negative\n\
 750                                 value locates all stubs before their branches\n\
 751                                 (with a group size of -N), while a positive\n\
 752                                 value allows two groups of input sections, one\n\
 753                                 before, and one after each stub section.\n\
 754                                 Values of +/-1 indicate the linker should\n\
 755                                 choose suitable defaults.\n"
 756                    ));
 757   fprintf (file, _("\
 758   --plt-static-chain          PLT call stubs should load r11.'${DEFAULT_PLT_STATIC_CHAIN- (default)}'\n"
 759                    ));
 760   fprintf (file, _("\
 761   --no-plt-static-chain       PLT call stubs should not load r11.'${DEFAULT_PLT_STATIC_CHAIN+ (default)}'\n"
 762                    ));
 763   fprintf (file, _("\
 764   --plt-thread-safe           PLT call stubs with load-load barrier.\n"
 765                    ));
 766   fprintf (file, _("\
 767   --no-plt-thread-safe        PLT call stubs without load-load barrier.\n"
 768                    ));
 769   fprintf (file, _("\
 770   --speculate-indirect-jumps  PLT call stubs without speculation barrier.\n"
 771                    ));
 772   fprintf (file, _("\
 773   --no-speculate-indirect-jumps PLT call stubs with speculation barrier.\n"
 774                    ));
 775   fprintf (file, _("\
 776   --plt-align [=<align>]      Align PLT call stubs to fit cache lines.\n"
 777                    ));
 778   fprintf (file, _("\
 779   --no-plt-align              Dont'\''t align individual PLT call stubs.\n"
 780                    ));
 781   fprintf (file, _("\
 782   --plt-localentry            Optimize calls to ELFv2 localentry:0 functions.\n"
 783                    ));
 784   fprintf (file, _("\
 785   --no-plt-localentry         Don'\''t optimize ELFv2 calls.\n"
 786                    ));
 787   fprintf (file, _("\
 788   --emit-stub-syms            Label linker stubs with a symbol.\n"
 789                    ));
 790   fprintf (file, _("\
 791   --no-emit-stub-syms         Don'\''t label linker stubs with a symbol.\n"
 792                    ));
 793   fprintf (file, _("\
 794   --dotsyms                   For every version pattern \"foo\" in a version\n\
 795                                 script, add \".foo\" so that function code\n\
 796                                 symbols are treated the same as function\n\
 797                                 descriptor symbols.  Defaults to on.\n"
 798                    ));
 799   fprintf (file, _("\
 800   --no-dotsyms                Don'\''t do anything special in version scripts.\n"
 801                    ));
 802   fprintf (file, _("\
 803   --save-restore-funcs        Provide register save and restore routines used\n\
 804                                 by gcc -Os code.  Defaults to on for normal\n\
 805                                 final link, off for ld -r.\n"
 806                    ));
 807   fprintf (file, _("\
 808   --no-save-restore-funcs     Don'\''t provide these routines.\n"
 809                    ));
 810   fprintf (file, _("\
 811   --no-tls-optimize           Don'\''t try to optimize TLS accesses.\n"
 812                    ));
 813   fprintf (file, _("\
 814   --tls-get-addr-optimize     Force use of special __tls_get_addr call.\n"
 815                    ));
 816   fprintf (file, _("\
 817   --no-tls-get-addr-optimize  Don'\''t use a special __tls_get_addr call.\n"
 818                    ));
 819   fprintf (file, _("\
 820   --no-opd-optimize           Don'\''t optimize the OPD section.\n"
 821                    ));
 822   fprintf (file, _("\
 823   --no-toc-optimize           Don'\''t optimize the TOC section.\n"
 824                    ));
 825   fprintf (file, _("\
 826   --no-multi-toc              Disallow automatic multiple toc sections.\n"
 827                    ));
 828   fprintf (file, _("\
 829   --no-toc-sort               Don'\''t sort TOC and GOT sections.\n"
 830                    ));
 831   fprintf (file, _("\
 832   --non-overlapping-opd       Canonicalize .opd, so that there are no\n\
 833                                 overlapping .opd entries.\n"
 834                    ));
 835 '
 836
 837 PARSE_AND_LIST_ARGS_CASES=${PARSE_AND_LIST_ARGS_CASES}'
 838     case OPTION_STUBGROUP_SIZE:
 839       {
 840         const char *end;
 841         params.group_size = bfd_scan_vma (optarg, &end, 0);
 842         if (*end)
 843           einfo (_("%P%F: invalid number `%s'\''\n"), optarg);
 844       }
 845       break;
 846
 847     case OPTION_PLT_STATIC_CHAIN:
 848       params.plt_static_chain = 1;
 849       break;
 850
 851     case OPTION_NO_PLT_STATIC_CHAIN:
 852       params.plt_static_chain = 0;
 853       break;
 854
 855     case OPTION_PLT_THREAD_SAFE:
 856       params.plt_thread_safe = 1;
 857       break;
 858
 859     case OPTION_NO_PLT_THREAD_SAFE:
 860       params.plt_thread_safe = 0;
 861       break;
 862
 863     case OPTION_SPECULATE_INDIRECT_JUMPS:
 864       params.speculate_indirect_jumps = 1;
 865       break;
 866
 867     case OPTION_NO_SPECULATE_INDIRECT_JUMPS:
 868       params.speculate_indirect_jumps = 0;
 869       break;
 870
 871     case OPTION_PLT_ALIGN:
 872       if (optarg != NULL)
 873         {
 874           char *end;
 875           unsigned long val = strtoul (optarg, &end, 0);
 876           if (*end || val > 8)
 877             einfo (_("%P%F: invalid --plt-align `%s'\''\n"), optarg);
 878           params.plt_stub_align = val;
 879         }
 880       else
 881         params.plt_stub_align = 5;
 882       break;
 883
 884     case OPTION_NO_PLT_ALIGN:
 885       params.plt_stub_align = 0;
 886       break;
 887
 888     case OPTION_PLT_LOCALENTRY:
 889       params.plt_localentry0 = 1;
 890       break;
 891
 892     case OPTION_NO_PLT_LOCALENTRY:
 893       params.plt_localentry0 = 0;
 894       break;
 895
 896     case OPTION_STUBSYMS:
 897       params.emit_stub_syms = 1;
 898       break;
 899
 900     case OPTION_NO_STUBSYMS:
 901       params.emit_stub_syms = 0;
 902       break;
 903
 904     case OPTION_DOTSYMS:
 905       dotsyms = 1;
 906       break;
 907
 908     case OPTION_NO_DOTSYMS:
 909       dotsyms = 0;
 910       break;
 911
 912     case OPTION_SAVRES:
 913       params.save_restore_funcs = 1;
 914       break;
 915
 916     case OPTION_NO_SAVRES:
 917       params.save_restore_funcs = 0;
 918       break;
 919
 920     case OPTION_NO_TLS_OPT:
 921       no_tls_opt = 1;
 922       break;
 923
 924     case OPTION_TLS_GET_ADDR_OPT:
 925       params.tls_get_addr_opt = 1;
 926       break;
 927
 928     case OPTION_NO_TLS_GET_ADDR_OPT:
 929       params.tls_get_addr_opt = 0;
 930       break;
 931
 932     case OPTION_NO_OPD_OPT:
 933       no_opd_opt = 1;
 934       break;
 935
 936     case OPTION_NO_TOC_OPT:
 937       no_toc_opt = 1;
 938       break;
 939
 940     case OPTION_NO_MULTI_TOC:
 941       params.no_multi_toc = 1;
 942       break;
 943
 944     case OPTION_NO_TOC_SORT:
 945       no_toc_sort = 1;
 946       break;
 947
 948     case OPTION_NON_OVERLAPPING_OPD:
 949       params.non_overlapping_opd = 1;
 950       break;
 951
 952     case OPTION_TRADITIONAL_FORMAT:
 953       no_tls_opt = 1;
 954       params.tls_get_addr_opt = 0;
 955       no_opd_opt = 1;
 956       no_toc_opt = 1;
 957       params.no_multi_toc = 1;
 958       no_toc_sort = 1;
 959       params.plt_static_chain = 1;
 960       return FALSE;
 961 '
 962
 963 # Put these extra ppc64elf routines in ld_${EMULATION_NAME}_emulation
 964 #
 965 LDEMUL_NEW_VERS_PATTERN=gld${EMULATION_NAME}_new_vers_pattern
 966 LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS=ppc_create_output_section_statements
 967 LDEMUL_AFTER_OPEN=ppc_after_open
 968 LDEMUL_BEFORE_ALLOCATION=ppc_before_allocation
 969 LDEMUL_AFTER_ALLOCATION=gld${EMULATION_NAME}_after_allocation
 970 LDEMUL_FINISH=gld${EMULATION_NAME}_finish