ld/emultempl/ppc64elf.em

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