ld/emultempl/ppc64elf.em

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