ld/emultempl/ppc64elf.em

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