ld/emultempl/ppc64elf.em

   1 # This shell script emits a C file. -*- C -*-
   2 # Copyright 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
   3 # Free Software Foundation, Inc.
   4 #
   5 # This file is part of the GNU Binutils.
   6 #
   7 # This program is free software; you can redistribute it and/or modify
   8 # it under the terms of the GNU General Public License as published by
   9 # the Free Software Foundation; either version 3 of the License, or
  10 # (at your option) any later version.
  11 #
  12 # This program is distributed in the hope that it will be useful,
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 # GNU General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU General Public License
  18 # along with this program; if not, write to the Free Software
  19 # Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20 # MA 02110-1301, USA.
  21 #
  22
  23 # This file is sourced from elf32.em, and defines extra powerpc64-elf
  24 # specific routines.
  25 #
  26 fragment <<EOF
  27
  28 #include "ldctor.h"
  29 #include "libbfd.h"
  30 #include "elf-bfd.h"
  31 #include "elf64-ppc.h"
  32
  33 /* Fake input file for stubs.  */
  34 static lang_input_statement_type *stub_file;
  35 static int stub_added = 0;
  36
  37 /* Whether we need to call ppc_layout_sections_again.  */
  38 static int need_laying_out = 0;
  39
  40 /* Maximum size of a group of input sections that can be handled by
  41    one stub section.  A value of +/-1 indicates the bfd back-end
  42    should use a suitable default size.  */
  43 static bfd_signed_vma group_size = 1;
  44
  45 /* Whether to add ".foo" entries for each "foo" in a version script.  */
  46 static int dotsyms = 1;
  47
  48 /* Whether to run tls optimization.  */
  49 static int no_tls_opt = 0;
  50 static int no_tls_get_addr_opt = 0;
  51
  52 /* Whether to run opd optimization.  */
  53 static int no_opd_opt = 0;
  54
  55 /* Whether to run toc optimization.  */
  56 static int no_toc_opt = 0;
  57
  58 /* Whether to allow multiple toc sections.  */
  59 static int no_multi_toc = 0;
  60
  61 /* Whether to emit symbols for stubs.  */
  62 static int emit_stub_syms = -1;
  63
  64 static asection *toc_section = 0;
  65
  66 /* Whether to canonicalize .opd so that there are no overlapping
  67    .opd entries.  */
  68 static int non_overlapping_opd = 0;
  69
  70 /* This is called before the input files are opened.  We create a new
  71    fake input file to hold the stub sections.  */
  72
  73 static void
  74 ppc_create_output_section_statements (void)
  75 {
  76   if (!(bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour
  77         && elf_object_id (link_info.output_bfd) == PPC64_ELF_DATA))
  78     return;
  79
  80   link_info.wrap_char = '.';
  81
  82   stub_file = lang_add_input_file ("linker stubs",
  83                                    lang_input_file_is_fake_enum,
  84                                    NULL);
  85   stub_file->the_bfd = bfd_create ("linker stubs", link_info.output_bfd);
  86   if (stub_file->the_bfd == NULL
  87       || !bfd_set_arch_mach (stub_file->the_bfd,
  88                              bfd_get_arch (link_info.output_bfd),
  89                              bfd_get_mach (link_info.output_bfd)))
  90     {
  91       einfo ("%F%P: can not create BFD %E\n");
  92       return;
  93     }
  94
  95   stub_file->the_bfd->flags |= BFD_LINKER_CREATED;
  96   ldlang_add_file (stub_file);
  97   ppc64_elf_init_stub_bfd (stub_file->the_bfd, &link_info);
  98 }
  99
 100 static void
 101 ppc_before_allocation (void)
 102 {
 103   if (stub_file != NULL)
 104     {
 105       if (!no_opd_opt
 106           && !ppc64_elf_edit_opd (&link_info, non_overlapping_opd))
 107         einfo ("%X%P: can not edit %s %E\n", "opd");
 108
 109       if (ppc64_elf_tls_setup (&link_info, no_tls_get_addr_opt, &no_multi_toc)
 110           && !no_tls_opt)
 111         {
 112           /* Size the sections.  This is premature, but we want to know the
 113              TLS segment layout so that certain optimizations can be done.  */
 114           expld.phase = lang_mark_phase_enum;
 115           expld.dataseg.phase = exp_dataseg_none;
 116           one_lang_size_sections_pass (NULL, TRUE);
 117
 118           if (!ppc64_elf_tls_optimize (&link_info))
 119             einfo ("%X%P: TLS problem %E\n");
 120
 121           /* We must not cache anything from the preliminary sizing.  */
 122           lang_reset_memory_regions ();
 123         }
 124
 125       if (!no_toc_opt
 126           && !link_info.relocatable
 127           && !ppc64_elf_edit_toc (&link_info))
 128         einfo ("%X%P: can not edit %s %E\n", "toc");
 129     }
 130
 131   gld${EMULATION_NAME}_before_allocation ();
 132 }
 133
 134 struct hook_stub_info
 135 {
 136   lang_statement_list_type add;
 137   asection *input_section;
 138 };
 139
 140 /* Traverse the linker tree to find the spot where the stub goes.  */
 141
 142 static bfd_boolean
 143 hook_in_stub (struct hook_stub_info *info, lang_statement_union_type **lp)
 144 {
 145   lang_statement_union_type *l;
 146   bfd_boolean ret;
 147
 148   for (; (l = *lp) != NULL; lp = &l->header.next)
 149     {
 150       switch (l->header.type)
 151         {
 152         case lang_constructors_statement_enum:
 153           ret = hook_in_stub (info, &constructor_list.head);
 154           if (ret)
 155             return ret;
 156           break;
 157
 158         case lang_output_section_statement_enum:
 159           ret = hook_in_stub (info,
 160                               &l->output_section_statement.children.head);
 161           if (ret)
 162             return ret;
 163           break;
 164
 165         case lang_wild_statement_enum:
 166           ret = hook_in_stub (info, &l->wild_statement.children.head);
 167           if (ret)
 168             return ret;
 169           break;
 170
 171         case lang_group_statement_enum:
 172           ret = hook_in_stub (info, &l->group_statement.children.head);
 173           if (ret)
 174             return ret;
 175           break;
 176
 177         case lang_input_section_enum:
 178           if (l->input_section.section == info->input_section)
 179             {
 180               /* We've found our section.  Insert the stub immediately
 181                  before its associated input section.  */
 182               *lp = info->add.head;
 183               *(info->add.tail) = l;
 184               return TRUE;
 185             }
 186           break;
 187
 188         case lang_data_statement_enum:
 189         case lang_reloc_statement_enum:
 190         case lang_object_symbols_statement_enum:
 191         case lang_output_statement_enum:
 192         case lang_target_statement_enum:
 193         case lang_input_statement_enum:
 194         case lang_assignment_statement_enum:
 195         case lang_padding_statement_enum:
 196         case lang_address_statement_enum:
 197         case lang_fill_statement_enum:
 198           break;
 199
 200         default:
 201           FAIL ();
 202           break;
 203         }
 204     }
 205   return FALSE;
 206 }
 207
 208
 209 /* Call-back for ppc64_elf_size_stubs.  */
 210
 211 /* Create a new stub section, and arrange for it to be linked
 212    immediately before INPUT_SECTION.  */
 213
 214 static asection *
 215 ppc_add_stub_section (const char *stub_sec_name, asection *input_section)
 216 {
 217   asection *stub_sec;
 218   flagword flags;
 219   asection *output_section;
 220   const char *secname;
 221   lang_output_section_statement_type *os;
 222   struct hook_stub_info info;
 223
 224   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE
 225            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_KEEP);
 226   stub_sec = bfd_make_section_anyway_with_flags (stub_file->the_bfd,
 227                                                  stub_sec_name, flags);
 228   if (stub_sec == NULL)
 229     goto err_ret;
 230
 231   output_section = input_section->output_section;
 232   secname = bfd_get_section_name (output_section->owner, output_section);
 233   os = lang_output_section_find (secname);
 234
 235   info.input_section = input_section;
 236   lang_list_init (&info.add);
 237   lang_add_section (&info.add, stub_sec, os);
 238
 239   if (info.add.head == NULL)
 240     goto err_ret;
 241
 242   stub_added = 1;
 243   if (hook_in_stub (&info, &os->children.head))
 244     return stub_sec;
 245
 246  err_ret:
 247   einfo ("%X%P: can not make stub section: %E\n");
 248   return NULL;
 249 }
 250
 251
 252 /* Another call-back for ppc64_elf_size_stubs.  */
 253
 254 static void
 255 ppc_layout_sections_again (void)
 256 {
 257   /* If we have changed sizes of the stub sections, then we need
 258      to recalculate all the section offsets.  This may mean we need to
 259      add even more stubs.  */
 260   gld${EMULATION_NAME}_map_segments (TRUE);
 261
 262   if (!link_info.relocatable)
 263     _bfd_set_gp_value (link_info.output_bfd,
 264                        ppc64_elf_toc (link_info.output_bfd));
 265
 266   need_laying_out = -1;
 267 }
 268
 269
 270 static void
 271 build_toc_list (lang_statement_union_type *statement)
 272 {
 273   if (statement->header.type == lang_input_section_enum)
 274     {
 275       asection *i = statement->input_section.section;
 276
 277       if (!((lang_input_statement_type *) i->owner->usrdata)->just_syms_flag
 278           && (i->flags & SEC_EXCLUDE) == 0
 279           && i->output_section == toc_section)
 280         {
 281           if (!ppc64_elf_next_toc_section (&link_info, i))
 282             einfo ("%X%P: linker script separates .got and .toc\n");
 283         }
 284     }
 285 }
 286
 287
 288 static void
 289 build_section_lists (lang_statement_union_type *statement)
 290 {
 291   if (statement->header.type == lang_input_section_enum)
 292     {
 293       asection *i = statement->input_section.section;
 294
 295       if (!((lang_input_statement_type *) i->owner->usrdata)->just_syms_flag
 296           && (i->flags & SEC_EXCLUDE) == 0
 297           && i->output_section != NULL
 298           && i->output_section->owner == link_info.output_bfd)
 299         {
 300           if (!ppc64_elf_next_input_section (&link_info, i))
 301             einfo ("%X%P: can not size stub section: %E\n");
 302         }
 303     }
 304 }
 305
 306
 307 /* Call the back-end function to set TOC base after we have placed all
 308    the sections.  */
 309 static void
 310 gld${EMULATION_NAME}_after_allocation (void)
 311 {
 312   /* bfd_elf_discard_info just plays with data and debugging sections,
 313      ie. doesn't affect code size, so we can delay resizing the
 314      sections.  It's likely we'll resize everything in the process of
 315      adding stubs.  */
 316   if (bfd_elf_discard_info (link_info.output_bfd, &link_info))
 317     need_laying_out = 1;
 318
 319   /* If generating a relocatable output file, then we don't have any
 320      stubs.  */
 321   if (stub_file != NULL && !link_info.relocatable)
 322     {
 323       int ret = ppc64_elf_setup_section_lists (&link_info,
 324                                                &ppc_add_stub_section,
 325                                                &ppc_layout_sections_again);
 326       if (ret < 0)
 327         einfo ("%X%P: can not size stub section: %E\n");
 328       else if (ret > 0)
 329         {
 330           ppc64_elf_start_multitoc_partition (&link_info);
 331
 332           if (!no_multi_toc)
 333             {
 334               toc_section = bfd_get_section_by_name (link_info.output_bfd,
 335                                                      ".got");
 336               if (toc_section != NULL)
 337                 lang_for_each_statement (build_toc_list);
 338             }
 339
 340           if (ppc64_elf_layout_multitoc (&link_info)
 341               && !no_multi_toc
 342               && toc_section != NULL)
 343             lang_for_each_statement (build_toc_list);
 344
 345           ppc64_elf_finish_multitoc_partition (&link_info);
 346
 347           lang_for_each_statement (build_section_lists);
 348
 349           if (!ppc64_elf_check_init_fini (&link_info))
 350             einfo ("%P: .init/.fini fragments use differing TOC pointers\n");
 351
 352           /* Call into the BFD backend to do the real work.  */
 353           if (!ppc64_elf_size_stubs (&link_info, group_size))
 354             einfo ("%X%P: can not size stub section: %E\n");
 355         }
 356     }
 357
 358   if (need_laying_out != -1)
 359     {
 360       gld${EMULATION_NAME}_map_segments (need_laying_out);
 361
 362       if (!link_info.relocatable)
 363         _bfd_set_gp_value (link_info.output_bfd,
 364                            ppc64_elf_toc (link_info.output_bfd));
 365     }
 366 }
 367
 368
 369 /* Final emulation specific call.  */
 370
 371 static void
 372 gld${EMULATION_NAME}_finish (void)
 373 {
 374   /* e_entry on PowerPC64 points to the function descriptor for
 375      _start.  If _start is missing, default to the first function
 376      descriptor in the .opd section.  */
 377   entry_section = ".opd";
 378
 379   if (link_info.relocatable)
 380     {
 381       asection *toc = bfd_get_section_by_name (link_info.output_bfd, ".toc");
 382       if (toc != NULL
 383           && bfd_section_size (link_info.output_bfd, toc) > 0x10000)
 384         einfo ("%X%P: TOC section size exceeds 64k\n");
 385     }
 386
 387   if (stub_added)
 388     {
 389       char *msg = NULL;
 390       char *line, *endline;
 391
 392       if (emit_stub_syms < 0)
 393         emit_stub_syms = 1;
 394       if (!ppc64_elf_build_stubs (emit_stub_syms, &link_info,
 395                                   config.stats ? &msg : NULL))
 396         einfo ("%X%P: can not build stubs: %E\n");
 397
 398       for (line = msg; line != NULL; line = endline)
 399         {
 400           endline = strchr (line, '\n');
 401           if (endline != NULL)
 402             *endline++ = '\0';
 403           fprintf (stderr, "%s: %s\n", program_name, line);
 404         }
 405       if (msg != NULL)
 406         free (msg);
 407     }
 408
 409   ppc64_elf_restore_symbols (&link_info);
 410   finish_default ();
 411 }
 412
 413
 414 /* Add a pattern matching ".foo" for every "foo" in a version script.
 415
 416    The reason for doing this is that many shared library version
 417    scripts export a selected set of functions or data symbols, forcing
 418    others local.  eg.
 419
 420    . VERS_1 {
 421    .       global:
 422    .               this; that; some; thing;
 423    .       local:
 424    .               *;
 425    .   };
 426
 427    To make the above work for PowerPC64, we need to export ".this",
 428    ".that" and so on, otherwise only the function descriptor syms are
 429    exported.  Lack of an exported function code sym may cause a
 430    definition to be pulled in from a static library.  */
 431
 432 static struct bfd_elf_version_expr *
 433 gld${EMULATION_NAME}_new_vers_pattern (struct bfd_elf_version_expr *entry)
 434 {
 435   struct bfd_elf_version_expr *dot_entry;
 436   unsigned int len;
 437   char *dot_pat;
 438
 439   if (!dotsyms
 440       || entry->pattern[0] == '.'
 441       || (!entry->literal && entry->pattern[0] == '*'))
 442     return entry;
 443
 444   dot_entry = xmalloc (sizeof *dot_entry);
 445   *dot_entry = *entry;
 446   dot_entry->next = entry;
 447   len = strlen (entry->pattern) + 2;
 448   dot_pat = xmalloc (len);
 449   dot_pat[0] = '.';
 450   memcpy (dot_pat + 1, entry->pattern, len - 1);
 451   dot_entry->pattern = dot_pat;
 452   return dot_entry;
 453 }
 454
 455
 456 /* Avoid processing the fake stub_file in vercheck, stat_needed and
 457    check_needed routines.  */
 458
 459 static void (*real_func) (lang_input_statement_type *);
 460
 461 static void ppc_for_each_input_file_wrapper (lang_input_statement_type *l)
 462 {
 463   if (l != stub_file)
 464     (*real_func) (l);
 465 }
 466
 467 static void
 468 ppc_lang_for_each_input_file (void (*func) (lang_input_statement_type *))
 469 {
 470   real_func = func;
 471   lang_for_each_input_file (&ppc_for_each_input_file_wrapper);
 472 }
 473
 474 #define lang_for_each_input_file ppc_lang_for_each_input_file
 475
 476 EOF
 477
 478 if grep -q 'ld_elf32_spu_emulation' ldemul-list.h; then
 479   fragment <<EOF
 480 /* Special handling for embedded SPU executables.  */
 481 extern bfd_boolean embedded_spu_file (lang_input_statement_type *, const char *);
 482 static bfd_boolean gld${EMULATION_NAME}_load_symbols (lang_input_statement_type *);
 483
 484 static bfd_boolean
 485 ppc64_recognized_file (lang_input_statement_type *entry)
 486 {
 487   if (embedded_spu_file (entry, "-m64"))
 488     return TRUE;
 489
 490   return gld${EMULATION_NAME}_load_symbols (entry);
 491 }
 492 EOF
 493 LDEMUL_RECOGNIZED_FILE=ppc64_recognized_file
 494 fi
 495
 496 # Define some shell vars to insert bits of code into the standard elf
 497 # parse_args and list_options functions.
 498 #
 499 PARSE_AND_LIST_PROLOGUE='
 500 #define OPTION_STUBGROUP_SIZE           301
 501 #define OPTION_STUBSYMS                 (OPTION_STUBGROUP_SIZE + 1)
 502 #define OPTION_NO_STUBSYMS              (OPTION_STUBSYMS + 1)
 503 #define OPTION_DOTSYMS                  (OPTION_NO_STUBSYMS + 1)
 504 #define OPTION_NO_DOTSYMS               (OPTION_DOTSYMS + 1)
 505 #define OPTION_NO_TLS_OPT               (OPTION_NO_DOTSYMS + 1)
 506 #define OPTION_NO_TLS_GET_ADDR_OPT      (OPTION_NO_TLS_OPT + 1)
 507 #define OPTION_NO_OPD_OPT               (OPTION_NO_TLS_GET_ADDR_OPT + 1)
 508 #define OPTION_NO_TOC_OPT               (OPTION_NO_OPD_OPT + 1)
 509 #define OPTION_NO_MULTI_TOC             (OPTION_NO_TOC_OPT + 1)
 510 #define OPTION_NON_OVERLAPPING_OPD      (OPTION_NO_MULTI_TOC + 1)
 511 '
 512
 513 PARSE_AND_LIST_LONGOPTS='
 514   { "stub-group-size", required_argument, NULL, OPTION_STUBGROUP_SIZE },
 515   { "emit-stub-syms", no_argument, NULL, OPTION_STUBSYMS },
 516   { "no-emit-stub-syms", no_argument, NULL, OPTION_NO_STUBSYMS },
 517   { "dotsyms", no_argument, NULL, OPTION_DOTSYMS },
 518   { "no-dotsyms", no_argument, NULL, OPTION_NO_DOTSYMS },
 519   { "no-tls-optimize", no_argument, NULL, OPTION_NO_TLS_OPT },
 520   { "no-tls-get-addr-optimize", no_argument, NULL, OPTION_NO_TLS_GET_ADDR_OPT },
 521   { "no-opd-optimize", no_argument, NULL, OPTION_NO_OPD_OPT },
 522   { "no-toc-optimize", no_argument, NULL, OPTION_NO_TOC_OPT },
 523   { "no-multi-toc", no_argument, NULL, OPTION_NO_MULTI_TOC },
 524   { "non-overlapping-opd", no_argument, NULL, OPTION_NON_OVERLAPPING_OPD },
 525 '
 526
 527 PARSE_AND_LIST_OPTIONS='
 528   fprintf (file, _("\
 529   --stub-group-size=N         Maximum size of a group of input sections that\n\
 530                                 can be handled by one stub section.  A negative\n\
 531                                 value locates all stubs before their branches\n\
 532                                 (with a group size of -N), while a positive\n\
 533                                 value allows two groups of input sections, one\n\
 534                                 before, and one after each stub section.\n\
 535                                 Values of +/-1 indicate the linker should\n\
 536                                 choose suitable defaults.\n"
 537                    ));
 538   fprintf (file, _("\
 539   --emit-stub-syms            Label linker stubs with a symbol.\n"
 540                    ));
 541   fprintf (file, _("\
 542   --no-emit-stub-syms         Don'\''t label linker stubs with a symbol.\n"
 543                    ));
 544   fprintf (file, _("\
 545   --dotsyms                   For every version pattern \"foo\" in a version\n\
 546                                 script, add \".foo\" so that function code\n\
 547                                 symbols are treated the same as function\n\
 548                                 descriptor symbols.  Defaults to on.\n"
 549                    ));
 550   fprintf (file, _("\
 551   --no-dotsyms                Don'\''t do anything special in version scripts.\n"
 552                    ));
 553   fprintf (file, _("\
 554   --no-tls-optimize           Don'\''t try to optimize TLS accesses.\n"
 555                    ));
 556   fprintf (file, _("\
 557   --no-tls-get-addr-optimize  Don'\''t use a special __tls_get_addr call.\n"
 558                    ));
 559   fprintf (file, _("\
 560   --no-opd-optimize           Don'\''t optimize the OPD section.\n"
 561                    ));
 562   fprintf (file, _("\
 563   --no-toc-optimize           Don'\''t optimize the TOC section.\n"
 564                    ));
 565   fprintf (file, _("\
 566   --no-multi-toc              Disallow automatic multiple toc sections.\n"
 567                    ));
 568   fprintf (file, _("\
 569   --non-overlapping-opd       Canonicalize .opd, so that there are no\n\
 570                                 overlapping .opd entries.\n"
 571                    ));
 572 '
 573
 574 PARSE_AND_LIST_ARGS_CASES='
 575     case OPTION_STUBGROUP_SIZE:
 576       {
 577         const char *end;
 578         group_size = bfd_scan_vma (optarg, &end, 0);
 579         if (*end)
 580           einfo (_("%P%F: invalid number `%s'\''\n"), optarg);
 581       }
 582       break;
 583
 584     case OPTION_STUBSYMS:
 585       emit_stub_syms = 1;
 586       break;
 587
 588     case OPTION_NO_STUBSYMS:
 589       emit_stub_syms = 0;
 590       break;
 591
 592     case OPTION_DOTSYMS:
 593       dotsyms = 1;
 594       break;
 595
 596     case OPTION_NO_DOTSYMS:
 597       dotsyms = 0;
 598       break;
 599
 600     case OPTION_NO_TLS_OPT:
 601       no_tls_opt = 1;
 602       break;
 603
 604     case OPTION_NO_TLS_GET_ADDR_OPT:
 605       no_tls_get_addr_opt = 1;
 606       break;
 607
 608     case OPTION_NO_OPD_OPT:
 609       no_opd_opt = 1;
 610       break;
 611
 612     case OPTION_NO_TOC_OPT:
 613       no_toc_opt = 1;
 614       break;
 615
 616     case OPTION_NO_MULTI_TOC:
 617       no_multi_toc = 1;
 618       break;
 619
 620     case OPTION_NON_OVERLAPPING_OPD:
 621       non_overlapping_opd = 1;
 622       break;
 623 '
 624
 625 # Put these extra ppc64elf routines in ld_${EMULATION_NAME}_emulation
 626 #
 627 LDEMUL_BEFORE_ALLOCATION=ppc_before_allocation
 628 LDEMUL_AFTER_ALLOCATION=gld${EMULATION_NAME}_after_allocation
 629 LDEMUL_FINISH=gld${EMULATION_NAME}_finish
 630 LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS=ppc_create_output_section_statements
 631 LDEMUL_NEW_VERS_PATTERN=gld${EMULATION_NAME}_new_vers_pattern