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   finish_default ();
 596 }
 597
 598
 599 /* Add a pattern matching ".foo" for every "foo" in a version script.
 600
 601    The reason for doing this is that many shared library version
 602    scripts export a selected set of functions or data symbols, forcing
 603    others local.  eg.
 604
 605    . VERS_1 {
 606    .       global:
 607    .               this; that; some; thing;
 608    .       local:
 609    .               *;
 610    .   };
 611
 612    To make the above work for PowerPC64, we need to export ".this",
 613    ".that" and so on, otherwise only the function descriptor syms are
 614    exported.  Lack of an exported function code sym may cause a
 615    definition to be pulled in from a static library.  */
 616
 617 static struct bfd_elf_version_expr *
 618 gld${EMULATION_NAME}_new_vers_pattern (struct bfd_elf_version_expr *entry)
 619 {
 620   struct bfd_elf_version_expr *dot_entry;
 621   unsigned int len;
 622   char *dot_pat;
 623
 624   if (!dotsyms
 625       || entry->pattern[0] == '.'
 626       || (!entry->literal && entry->pattern[0] == '*'))
 627     return entry;
 628
 629   dot_entry = xmalloc (sizeof *dot_entry);
 630   *dot_entry = *entry;
 631   dot_entry->next = entry;
 632   len = strlen (entry->pattern) + 2;
 633   dot_pat = xmalloc (len);
 634   dot_pat[0] = '.';
 635   memcpy (dot_pat + 1, entry->pattern, len - 1);
 636   dot_entry->pattern = dot_pat;
 637   dot_entry->script = 1;
 638   return dot_entry;
 639 }
 640
 641
 642 /* Avoid processing the fake stub_file in vercheck, stat_needed and
 643    check_needed routines.  */
 644
 645 static void (*real_func) (lang_input_statement_type *);
 646
 647 static void ppc_for_each_input_file_wrapper (lang_input_statement_type *l)
 648 {
 649   if (l != stub_file)
 650     (*real_func) (l);
 651 }
 652
 653 static void
 654 ppc_lang_for_each_input_file (void (*func) (lang_input_statement_type *))
 655 {
 656   real_func = func;
 657   lang_for_each_input_file (&ppc_for_each_input_file_wrapper);
 658 }
 659
 660 #define lang_for_each_input_file ppc_lang_for_each_input_file
 661
 662 EOF
 663
 664 if grep -q 'ld_elf32_spu_emulation' ldemul-list.h; then
 665   fragment <<EOF
 666 /* Special handling for embedded SPU executables.  */
 667 extern bfd_boolean embedded_spu_file (lang_input_statement_type *, const char *);
 668 static bfd_boolean gld${EMULATION_NAME}_load_symbols (lang_input_statement_type *);
 669
 670 static bfd_boolean
 671 ppc64_recognized_file (lang_input_statement_type *entry)
 672 {
 673   if (embedded_spu_file (entry, "-m64"))
 674     return TRUE;
 675
 676   return gld${EMULATION_NAME}_load_symbols (entry);
 677 }
 678 EOF
 679 LDEMUL_RECOGNIZED_FILE=ppc64_recognized_file
 680 fi
 681
 682 # Define some shell vars to insert bits of code into the standard elf
 683 # parse_args and list_options functions.
 684 #
 685 PARSE_AND_LIST_PROLOGUE=${PARSE_AND_LIST_PROLOGUE}'
 686 #define OPTION_STUBGROUP_SIZE           321
 687 #define OPTION_PLT_STATIC_CHAIN         (OPTION_STUBGROUP_SIZE + 1)
 688 #define OPTION_NO_PLT_STATIC_CHAIN      (OPTION_PLT_STATIC_CHAIN + 1)
 689 #define OPTION_PLT_THREAD_SAFE          (OPTION_NO_PLT_STATIC_CHAIN + 1)
 690 #define OPTION_NO_PLT_THREAD_SAFE       (OPTION_PLT_THREAD_SAFE + 1)
 691 #define OPTION_PLT_ALIGN                (OPTION_NO_PLT_THREAD_SAFE + 1)
 692 #define OPTION_NO_PLT_ALIGN             (OPTION_PLT_ALIGN + 1)
 693 #define OPTION_STUBSYMS                 (OPTION_NO_PLT_ALIGN + 1)
 694 #define OPTION_NO_STUBSYMS              (OPTION_STUBSYMS + 1)
 695 #define OPTION_SAVRES                   (OPTION_NO_STUBSYMS + 1)
 696 #define OPTION_NO_SAVRES                (OPTION_SAVRES + 1)
 697 #define OPTION_DOTSYMS                  (OPTION_NO_SAVRES + 1)
 698 #define OPTION_NO_DOTSYMS               (OPTION_DOTSYMS + 1)
 699 #define OPTION_NO_TLS_OPT               (OPTION_NO_DOTSYMS + 1)
 700 #define OPTION_TLS_GET_ADDR_OPT         (OPTION_NO_TLS_OPT + 1)
 701 #define OPTION_NO_TLS_GET_ADDR_OPT      (OPTION_TLS_GET_ADDR_OPT + 1)
 702 #define OPTION_NO_OPD_OPT               (OPTION_NO_TLS_GET_ADDR_OPT + 1)
 703 #define OPTION_NO_TOC_OPT               (OPTION_NO_OPD_OPT + 1)
 704 #define OPTION_NO_MULTI_TOC             (OPTION_NO_TOC_OPT + 1)
 705 #define OPTION_NO_TOC_SORT              (OPTION_NO_MULTI_TOC + 1)
 706 #define OPTION_NON_OVERLAPPING_OPD      (OPTION_NO_TOC_SORT + 1)
 707 '
 708
 709 PARSE_AND_LIST_LONGOPTS=${PARSE_AND_LIST_LONGOPTS}'
 710   { "stub-group-size", required_argument, NULL, OPTION_STUBGROUP_SIZE },
 711   { "plt-static-chain", no_argument, NULL, OPTION_PLT_STATIC_CHAIN },
 712   { "no-plt-static-chain", no_argument, NULL, OPTION_NO_PLT_STATIC_CHAIN },
 713   { "plt-thread-safe", no_argument, NULL, OPTION_PLT_THREAD_SAFE },
 714   { "no-plt-thread-safe", no_argument, NULL, OPTION_NO_PLT_THREAD_SAFE },
 715   { "plt-align", optional_argument, NULL, OPTION_PLT_ALIGN },
 716   { "no-plt-align", no_argument, NULL, OPTION_NO_PLT_ALIGN },
 717   { "emit-stub-syms", no_argument, NULL, OPTION_STUBSYMS },
 718   { "no-emit-stub-syms", no_argument, NULL, OPTION_NO_STUBSYMS },
 719   { "dotsyms", no_argument, NULL, OPTION_DOTSYMS },
 720   { "no-dotsyms", no_argument, NULL, OPTION_NO_DOTSYMS },
 721   { "save-restore-funcs", no_argument, NULL, OPTION_SAVRES },
 722   { "no-save-restore-funcs", no_argument, NULL, OPTION_NO_SAVRES },
 723   { "no-tls-optimize", no_argument, NULL, OPTION_NO_TLS_OPT },
 724   { "tls-get-addr-optimize", no_argument, NULL, OPTION_TLS_GET_ADDR_OPT },
 725   { "no-tls-get-addr-optimize", no_argument, NULL, OPTION_NO_TLS_GET_ADDR_OPT },
 726   { "no-opd-optimize", no_argument, NULL, OPTION_NO_OPD_OPT },
 727   { "no-toc-optimize", no_argument, NULL, OPTION_NO_TOC_OPT },
 728   { "no-multi-toc", no_argument, NULL, OPTION_NO_MULTI_TOC },
 729   { "no-toc-sort", no_argument, NULL, OPTION_NO_TOC_SORT },
 730   { "non-overlapping-opd", no_argument, NULL, OPTION_NON_OVERLAPPING_OPD },
 731 '
 732
 733 PARSE_AND_LIST_OPTIONS=${PARSE_AND_LIST_OPTIONS}'
 734   fprintf (file, _("\
 735   --stub-group-size=N         Maximum size of a group of input sections that\n\
 736                                 can be handled by one stub section.  A negative\n\
 737                                 value locates all stubs before their branches\n\
 738                                 (with a group size of -N), while a positive\n\
 739                                 value allows two groups of input sections, one\n\
 740                                 before, and one after each stub section.\n\
 741                                 Values of +/-1 indicate the linker should\n\
 742                                 choose suitable defaults.\n"
 743                    ));
 744   fprintf (file, _("\
 745   --plt-static-chain          PLT call stubs should load r11.${DEFAULT_PLT_STATIC_CHAIN- (default)}\n"
 746                    ));
 747   fprintf (file, _("\
 748   --no-plt-static-chain       PLT call stubs should not load r11.${DEFAULT_PLT_STATIC_CHAIN+ (default)}\n"
 749                    ));
 750   fprintf (file, _("\
 751   --plt-thread-safe           PLT call stubs with load-load barrier.\n"
 752                    ));
 753   fprintf (file, _("\
 754   --no-plt-thread-safe        PLT call stubs without barrier.\n"
 755                    ));
 756   fprintf (file, _("\
 757   --plt-align [=<align>]      Align PLT call stubs to fit cache lines.\n"
 758                    ));
 759   fprintf (file, _("\
 760   --no-plt-align              Dont'\''t align individual PLT call stubs.\n"
 761                    ));
 762   fprintf (file, _("\
 763   --emit-stub-syms            Label linker stubs with a symbol.\n"
 764                    ));
 765   fprintf (file, _("\
 766   --no-emit-stub-syms         Don'\''t label linker stubs with a symbol.\n"
 767                    ));
 768   fprintf (file, _("\
 769   --dotsyms                   For every version pattern \"foo\" in a version\n\
 770                                 script, add \".foo\" so that function code\n\
 771                                 symbols are treated the same as function\n\
 772                                 descriptor symbols.  Defaults to on.\n"
 773                    ));
 774   fprintf (file, _("\
 775   --no-dotsyms                Don'\''t do anything special in version scripts.\n"
 776                    ));
 777   fprintf (file, _("\
 778   --save-restore-funcs        Provide register save and restore routines used\n\
 779                                 by gcc -Os code.  Defaults to on for normal\n\
 780                                 final link, off for ld -r.\n"
 781                    ));
 782   fprintf (file, _("\
 783   --no-save-restore-funcs     Don'\''t provide these routines.\n"
 784                    ));
 785   fprintf (file, _("\
 786   --no-tls-optimize           Don'\''t try to optimize TLS accesses.\n"
 787                    ));
 788   fprintf (file, _("\
 789   --tls-get-addr-optimize     Force use of special __tls_get_addr call.\n"
 790                    ));
 791   fprintf (file, _("\
 792   --no-tls-get-addr-optimize  Don'\''t use a special __tls_get_addr call.\n"
 793                    ));
 794   fprintf (file, _("\
 795   --no-opd-optimize           Don'\''t optimize the OPD section.\n"
 796                    ));
 797   fprintf (file, _("\
 798   --no-toc-optimize           Don'\''t optimize the TOC section.\n"
 799                    ));
 800   fprintf (file, _("\
 801   --no-multi-toc              Disallow automatic multiple toc sections.\n"
 802                    ));
 803   fprintf (file, _("\
 804   --no-toc-sort               Don'\''t sort TOC and GOT sections.\n"
 805                    ));
 806   fprintf (file, _("\
 807   --non-overlapping-opd       Canonicalize .opd, so that there are no\n\
 808                                 overlapping .opd entries.\n"
 809                    ));
 810 '
 811
 812 PARSE_AND_LIST_ARGS_CASES=${PARSE_AND_LIST_ARGS_CASES}'
 813     case OPTION_STUBGROUP_SIZE:
 814       {
 815         const char *end;
 816         params.group_size = bfd_scan_vma (optarg, &end, 0);
 817         if (*end)
 818           einfo (_("%P%F: invalid number `%s'\''\n"), optarg);
 819       }
 820       break;
 821
 822     case OPTION_PLT_STATIC_CHAIN:
 823       params.plt_static_chain = 1;
 824       break;
 825
 826     case OPTION_NO_PLT_STATIC_CHAIN:
 827       params.plt_static_chain = 0;
 828       break;
 829
 830     case OPTION_PLT_THREAD_SAFE:
 831       params.plt_thread_safe = 1;
 832       break;
 833
 834     case OPTION_NO_PLT_THREAD_SAFE:
 835       params.plt_thread_safe = 0;
 836       break;
 837
 838     case OPTION_PLT_ALIGN:
 839       if (optarg != NULL)
 840         {
 841           char *end;
 842           unsigned long val = strtoul (optarg, &end, 0);
 843           if (*end || val > 8)
 844             einfo (_("%P%F: invalid --plt-align `%s'\''\n"), optarg);
 845           params.plt_stub_align = val;
 846         }
 847       else
 848         params.plt_stub_align = 5;
 849       break;
 850
 851     case OPTION_NO_PLT_ALIGN:
 852       params.plt_stub_align = 0;
 853       break;
 854
 855     case OPTION_STUBSYMS:
 856       params.emit_stub_syms = 1;
 857       break;
 858
 859     case OPTION_NO_STUBSYMS:
 860       params.emit_stub_syms = 0;
 861       break;
 862
 863     case OPTION_DOTSYMS:
 864       dotsyms = 1;
 865       break;
 866
 867     case OPTION_NO_DOTSYMS:
 868       dotsyms = 0;
 869       break;
 870
 871     case OPTION_SAVRES:
 872       params.save_restore_funcs = 1;
 873       break;
 874
 875     case OPTION_NO_SAVRES:
 876       params.save_restore_funcs = 0;
 877       break;
 878
 879     case OPTION_NO_TLS_OPT:
 880       no_tls_opt = 1;
 881       break;
 882
 883     case OPTION_TLS_GET_ADDR_OPT:
 884       params.tls_get_addr_opt = 1;
 885       break;
 886
 887     case OPTION_NO_TLS_GET_ADDR_OPT:
 888       params.tls_get_addr_opt = 0;
 889       break;
 890
 891     case OPTION_NO_OPD_OPT:
 892       no_opd_opt = 1;
 893       break;
 894
 895     case OPTION_NO_TOC_OPT:
 896       no_toc_opt = 1;
 897       break;
 898
 899     case OPTION_NO_MULTI_TOC:
 900       params.no_multi_toc = 1;
 901       break;
 902
 903     case OPTION_NO_TOC_SORT:
 904       no_toc_sort = 1;
 905       break;
 906
 907     case OPTION_NON_OVERLAPPING_OPD:
 908       params.non_overlapping_opd = 1;
 909       break;
 910
 911     case OPTION_TRADITIONAL_FORMAT:
 912       no_tls_opt = 1;
 913       params.tls_get_addr_opt = 0;
 914       no_opd_opt = 1;
 915       no_toc_opt = 1;
 916       params.no_multi_toc = 1;
 917       no_toc_sort = 1;
 918       params.plt_static_chain = 1;
 919       return FALSE;
 920 '
 921
 922 # Put these extra ppc64elf routines in ld_${EMULATION_NAME}_emulation
 923 #
 924 LDEMUL_NEW_VERS_PATTERN=gld${EMULATION_NAME}_new_vers_pattern
 925 LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS=ppc_create_output_section_statements
 926 LDEMUL_AFTER_OPEN=ppc_after_open
 927 LDEMUL_BEFORE_ALLOCATION=ppc_before_allocation
 928 LDEMUL_AFTER_ALLOCATION=gld${EMULATION_NAME}_after_allocation
 929 LDEMUL_FINISH=gld${EMULATION_NAME}_finish