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