ld/emultempl/ppc64elf.em

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