ld/emultempl/ppc64elf.em

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