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           /* Call into the BFD backend to do the real work.  */
 350           if (!ppc64_elf_size_stubs (&link_info, group_size))
 351             einfo ("%X%P: can not size stub section: %E\n");
 352         }
 353     }
 354
 355   if (need_laying_out != -1)
 356     {
 357       gld${EMULATION_NAME}_map_segments (need_laying_out);
 358
 359       if (!link_info.relocatable)
 360         _bfd_set_gp_value (link_info.output_bfd,
 361                            ppc64_elf_toc (link_info.output_bfd));
 362     }
 363 }
 364
 365
 366 /* Final emulation specific call.  */
 367
 368 static void
 369 gld${EMULATION_NAME}_finish (void)
 370 {
 371   /* e_entry on PowerPC64 points to the function descriptor for
 372      _start.  If _start is missing, default to the first function
 373      descriptor in the .opd section.  */
 374   entry_section = ".opd";
 375
 376   if (link_info.relocatable)
 377     {
 378       asection *toc = bfd_get_section_by_name (link_info.output_bfd, ".toc");
 379       if (toc != NULL
 380           && bfd_section_size (link_info.output_bfd, toc) > 0x10000)
 381         einfo ("%X%P: TOC section size exceeds 64k\n");
 382     }
 383
 384   if (stub_added)
 385     {
 386       char *msg = NULL;
 387       char *line, *endline;
 388
 389       if (emit_stub_syms < 0)
 390         emit_stub_syms = 1;
 391       if (!ppc64_elf_build_stubs (emit_stub_syms, &link_info,
 392                                   config.stats ? &msg : NULL))
 393         einfo ("%X%P: can not build stubs: %E\n");
 394
 395       for (line = msg; line != NULL; line = endline)
 396         {
 397           endline = strchr (line, '\n');
 398           if (endline != NULL)
 399             *endline++ = '\0';
 400           fprintf (stderr, "%s: %s\n", program_name, line);
 401         }
 402       if (msg != NULL)
 403         free (msg);
 404     }
 405
 406   ppc64_elf_restore_symbols (&link_info);
 407   finish_default ();
 408 }
 409
 410
 411 /* Add a pattern matching ".foo" for every "foo" in a version script.
 412
 413    The reason for doing this is that many shared library version
 414    scripts export a selected set of functions or data symbols, forcing
 415    others local.  eg.
 416
 417    . VERS_1 {
 418    .       global:
 419    .               this; that; some; thing;
 420    .       local:
 421    .               *;
 422    .   };
 423
 424    To make the above work for PowerPC64, we need to export ".this",
 425    ".that" and so on, otherwise only the function descriptor syms are
 426    exported.  Lack of an exported function code sym may cause a
 427    definition to be pulled in from a static library.  */
 428
 429 static struct bfd_elf_version_expr *
 430 gld${EMULATION_NAME}_new_vers_pattern (struct bfd_elf_version_expr *entry)
 431 {
 432   struct bfd_elf_version_expr *dot_entry;
 433   unsigned int len;
 434   char *dot_pat;
 435
 436   if (!dotsyms
 437       || entry->pattern[0] == '.'
 438       || (!entry->literal && entry->pattern[0] == '*'))
 439     return entry;
 440
 441   dot_entry = xmalloc (sizeof *dot_entry);
 442   *dot_entry = *entry;
 443   dot_entry->next = entry;
 444   len = strlen (entry->pattern) + 2;
 445   dot_pat = xmalloc (len);
 446   dot_pat[0] = '.';
 447   memcpy (dot_pat + 1, entry->pattern, len - 1);
 448   dot_entry->pattern = dot_pat;
 449   return dot_entry;
 450 }
 451
 452
 453 /* Avoid processing the fake stub_file in vercheck, stat_needed and
 454    check_needed routines.  */
 455
 456 static void (*real_func) (lang_input_statement_type *);
 457
 458 static void ppc_for_each_input_file_wrapper (lang_input_statement_type *l)
 459 {
 460   if (l != stub_file)
 461     (*real_func) (l);
 462 }
 463
 464 static void
 465 ppc_lang_for_each_input_file (void (*func) (lang_input_statement_type *))
 466 {
 467   real_func = func;
 468   lang_for_each_input_file (&ppc_for_each_input_file_wrapper);
 469 }
 470
 471 #define lang_for_each_input_file ppc_lang_for_each_input_file
 472
 473 EOF
 474
 475 if grep -q 'ld_elf32_spu_emulation' ldemul-list.h; then
 476   fragment <<EOF
 477 /* Special handling for embedded SPU executables.  */
 478 extern bfd_boolean embedded_spu_file (lang_input_statement_type *, const char *);
 479 static bfd_boolean gld${EMULATION_NAME}_load_symbols (lang_input_statement_type *);
 480
 481 static bfd_boolean
 482 ppc64_recognized_file (lang_input_statement_type *entry)
 483 {
 484   if (embedded_spu_file (entry, "-m64"))
 485     return TRUE;
 486
 487   return gld${EMULATION_NAME}_load_symbols (entry);
 488 }
 489 EOF
 490 LDEMUL_RECOGNIZED_FILE=ppc64_recognized_file
 491 fi
 492
 493 # Define some shell vars to insert bits of code into the standard elf
 494 # parse_args and list_options functions.
 495 #
 496 PARSE_AND_LIST_PROLOGUE='
 497 #define OPTION_STUBGROUP_SIZE           301
 498 #define OPTION_STUBSYMS                 (OPTION_STUBGROUP_SIZE + 1)
 499 #define OPTION_NO_STUBSYMS              (OPTION_STUBSYMS + 1)
 500 #define OPTION_DOTSYMS                  (OPTION_NO_STUBSYMS + 1)
 501 #define OPTION_NO_DOTSYMS               (OPTION_DOTSYMS + 1)
 502 #define OPTION_NO_TLS_OPT               (OPTION_NO_DOTSYMS + 1)
 503 #define OPTION_NO_TLS_GET_ADDR_OPT      (OPTION_NO_TLS_OPT + 1)
 504 #define OPTION_NO_OPD_OPT               (OPTION_NO_TLS_GET_ADDR_OPT + 1)
 505 #define OPTION_NO_TOC_OPT               (OPTION_NO_OPD_OPT + 1)
 506 #define OPTION_NO_MULTI_TOC             (OPTION_NO_TOC_OPT + 1)
 507 #define OPTION_NON_OVERLAPPING_OPD      (OPTION_NO_MULTI_TOC + 1)
 508 '
 509
 510 PARSE_AND_LIST_LONGOPTS='
 511   { "stub-group-size", required_argument, NULL, OPTION_STUBGROUP_SIZE },
 512   { "emit-stub-syms", no_argument, NULL, OPTION_STUBSYMS },
 513   { "no-emit-stub-syms", no_argument, NULL, OPTION_NO_STUBSYMS },
 514   { "dotsyms", no_argument, NULL, OPTION_DOTSYMS },
 515   { "no-dotsyms", no_argument, NULL, OPTION_NO_DOTSYMS },
 516   { "no-tls-optimize", no_argument, NULL, OPTION_NO_TLS_OPT },
 517   { "no-tls-get-addr-optimize", no_argument, NULL, OPTION_NO_TLS_GET_ADDR_OPT },
 518   { "no-opd-optimize", no_argument, NULL, OPTION_NO_OPD_OPT },
 519   { "no-toc-optimize", no_argument, NULL, OPTION_NO_TOC_OPT },
 520   { "no-multi-toc", no_argument, NULL, OPTION_NO_MULTI_TOC },
 521   { "non-overlapping-opd", no_argument, NULL, OPTION_NON_OVERLAPPING_OPD },
 522 '
 523
 524 PARSE_AND_LIST_OPTIONS='
 525   fprintf (file, _("\
 526   --stub-group-size=N         Maximum size of a group of input sections that\n\
 527                                 can be handled by one stub section.  A negative\n\
 528                                 value locates all stubs before their branches\n\
 529                                 (with a group size of -N), while a positive\n\
 530                                 value allows two groups of input sections, one\n\
 531                                 before, and one after each stub section.\n\
 532                                 Values of +/-1 indicate the linker should\n\
 533                                 choose suitable defaults.\n"
 534                    ));
 535   fprintf (file, _("\
 536   --emit-stub-syms            Label linker stubs with a symbol.\n"
 537                    ));
 538   fprintf (file, _("\
 539   --no-emit-stub-syms         Don'\''t label linker stubs with a symbol.\n"
 540                    ));
 541   fprintf (file, _("\
 542   --dotsyms                   For every version pattern \"foo\" in a version\n\
 543                                 script, add \".foo\" so that function code\n\
 544                                 symbols are treated the same as function\n\
 545                                 descriptor symbols.  Defaults to on.\n"
 546                    ));
 547   fprintf (file, _("\
 548   --no-dotsyms                Don'\''t do anything special in version scripts.\n"
 549                    ));
 550   fprintf (file, _("\
 551   --no-tls-optimize           Don'\''t try to optimize TLS accesses.\n"
 552                    ));
 553   fprintf (file, _("\
 554   --no-tls-get-addr-optimize  Don'\''t use a special __tls_get_addr call.\n"
 555                    ));
 556   fprintf (file, _("\
 557   --no-opd-optimize           Don'\''t optimize the OPD section.\n"
 558                    ));
 559   fprintf (file, _("\
 560   --no-toc-optimize           Don'\''t optimize the TOC section.\n"
 561                    ));
 562   fprintf (file, _("\
 563   --no-multi-toc              Disallow automatic multiple toc sections.\n"
 564                    ));
 565   fprintf (file, _("\
 566   --non-overlapping-opd       Canonicalize .opd, so that there are no\n\
 567                                 overlapping .opd entries.\n"
 568                    ));
 569 '
 570
 571 PARSE_AND_LIST_ARGS_CASES='
 572     case OPTION_STUBGROUP_SIZE:
 573       {
 574         const char *end;
 575         group_size = bfd_scan_vma (optarg, &end, 0);
 576         if (*end)
 577           einfo (_("%P%F: invalid number `%s'\''\n"), optarg);
 578       }
 579       break;
 580
 581     case OPTION_STUBSYMS:
 582       emit_stub_syms = 1;
 583       break;
 584
 585     case OPTION_NO_STUBSYMS:
 586       emit_stub_syms = 0;
 587       break;
 588
 589     case OPTION_DOTSYMS:
 590       dotsyms = 1;
 591       break;
 592
 593     case OPTION_NO_DOTSYMS:
 594       dotsyms = 0;
 595       break;
 596
 597     case OPTION_NO_TLS_OPT:
 598       no_tls_opt = 1;
 599       break;
 600
 601     case OPTION_NO_TLS_GET_ADDR_OPT:
 602       no_tls_get_addr_opt = 1;
 603       break;
 604
 605     case OPTION_NO_OPD_OPT:
 606       no_opd_opt = 1;
 607       break;
 608
 609     case OPTION_NO_TOC_OPT:
 610       no_toc_opt = 1;
 611       break;
 612
 613     case OPTION_NO_MULTI_TOC:
 614       no_multi_toc = 1;
 615       break;
 616
 617     case OPTION_NON_OVERLAPPING_OPD:
 618       non_overlapping_opd = 1;
 619       break;
 620 '
 621
 622 # Put these extra ppc64elf routines in ld_${EMULATION_NAME}_emulation
 623 #
 624 LDEMUL_BEFORE_ALLOCATION=ppc_before_allocation
 625 LDEMUL_AFTER_ALLOCATION=gld${EMULATION_NAME}_after_allocation
 626 LDEMUL_FINISH=gld${EMULATION_NAME}_finish
 627 LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS=ppc_create_output_section_statements
 628 LDEMUL_NEW_VERS_PATTERN=gld${EMULATION_NAME}_new_vers_pattern