ld/emultempl/ppc64elf.em

   1 # This shell script emits a C file. -*- C -*-
   2 #   Copyright 2002, 2003 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 "elf64-ppc.h"
  29
  30 /* Fake input file for stubs.  */
  31 static lang_input_statement_type *stub_file;
  32
  33 /* Whether we need to call ppc_layout_sections_again.  */
  34 static int need_laying_out = 0;
  35
  36 /* Maximum size of a group of input sections that can be handled by
  37    one stub section.  A value of +/-1 indicates the bfd back-end
  38    should use a suitable default size.  */
  39 static bfd_signed_vma group_size = 1;
  40
  41 /* Whether to add ".foo" entries for each "foo" in a version script.  */
  42 static int dotsyms = 1;
  43
  44 /* Whether to run tls optimization.  */
  45 static int notlsopt = 0;
  46
  47 /* Whether to emit symbols for stubs.  */
  48 static int emit_stub_syms = 0;
  49
  50 static asection *toc_section = 0;
  51
  52 static void ppc_create_output_section_statements
  53   PARAMS ((void));
  54 static void ppc_after_open
  55   PARAMS ((void));
  56 static void ppc_before_allocation
  57   PARAMS ((void));
  58 static asection *ppc_add_stub_section
  59   PARAMS ((const char *, asection *));
  60 static void ppc_layout_sections_again
  61   PARAMS ((void));
  62 static void gld${EMULATION_NAME}_after_allocation
  63   PARAMS ((void));
  64 static void build_toc_list
  65   PARAMS ((lang_statement_union_type *));
  66 static void build_section_lists
  67   PARAMS ((lang_statement_union_type *));
  68 static struct bfd_elf_version_expr *gld${EMULATION_NAME}_new_vers_pattern
  69   PARAMS ((struct bfd_elf_version_expr *));
  70
  71 /* This is called before the input files are opened.  We create a new
  72    fake input file to hold the stub sections.  */
  73
  74 static void
  75 ppc_create_output_section_statements ()
  76 {
  77   extern const bfd_target bfd_elf64_powerpc_vec;
  78   extern const bfd_target bfd_elf64_powerpcle_vec;
  79
  80   if (link_info.hash->creator != &bfd_elf64_powerpc_vec
  81       && link_info.hash->creator != &bfd_elf64_powerpcle_vec)
  82     return;
  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", output_bfd);
  88   if (stub_file->the_bfd == NULL
  89       || !bfd_set_arch_mach (stub_file->the_bfd,
  90                              bfd_get_arch (output_bfd),
  91                              bfd_get_mach (output_bfd)))
  92     {
  93       einfo ("%X%P: can not create BFD %E\n");
  94       return;
  95     }
  96
  97   ldlang_add_file (stub_file);
  98 }
  99
 100 static void
 101 ppc_after_open ()
 102 {
 103   if (!ppc64_elf_mark_entry_syms (&link_info))
 104     {
 105       einfo ("%X%P: can not mark entry symbols %E\n");
 106       return;
 107     }
 108
 109   gld${EMULATION_NAME}_after_open ();
 110 }
 111
 112 static void
 113 ppc_before_allocation ()
 114 {
 115   if (stub_file != NULL)
 116     {
 117       if (!ppc64_elf_edit_opd (output_bfd, &link_info))
 118         {
 119           einfo ("%X%P: can not edit opd %E\n");
 120           return;
 121         }
 122
 123       if (ppc64_elf_tls_setup (output_bfd, &link_info) && !notlsopt)
 124         {
 125           /* Size the sections.  This is premature, but we want to know the
 126              TLS segment layout so that certain optimizations can be done.  */
 127           lang_size_sections (stat_ptr->head, abs_output_section,
 128                               &stat_ptr->head, 0, (bfd_vma) 0, NULL, TRUE);
 129
 130           if (!ppc64_elf_tls_optimize (output_bfd, &link_info))
 131             {
 132               einfo ("%X%P: TLS problem %E\n");
 133               return;
 134             }
 135
 136           lang_reset_memory_regions ();
 137         }
 138     }
 139
 140   gld${EMULATION_NAME}_before_allocation ();
 141 }
 142
 143 struct hook_stub_info
 144 {
 145   lang_statement_list_type add;
 146   asection *input_section;
 147 };
 148
 149 /* Traverse the linker tree to find the spot where the stub goes.  */
 150
 151 static bfd_boolean hook_in_stub
 152   PARAMS ((struct hook_stub_info *, lang_statement_union_type **));
 153
 154 static bfd_boolean
 155 hook_in_stub (info, lp)
 156      struct hook_stub_info *info;
 157      lang_statement_union_type **lp;
 158 {
 159   lang_statement_union_type *l;
 160   bfd_boolean ret;
 161
 162   for (; (l = *lp) != NULL; lp = &l->header.next)
 163     {
 164       switch (l->header.type)
 165         {
 166         case lang_constructors_statement_enum:
 167           ret = hook_in_stub (info, &constructor_list.head);
 168           if (ret)
 169             return ret;
 170           break;
 171
 172         case lang_output_section_statement_enum:
 173           ret = hook_in_stub (info,
 174                               &l->output_section_statement.children.head);
 175           if (ret)
 176             return ret;
 177           break;
 178
 179         case lang_wild_statement_enum:
 180           ret = hook_in_stub (info, &l->wild_statement.children.head);
 181           if (ret)
 182             return ret;
 183           break;
 184
 185         case lang_group_statement_enum:
 186           ret = hook_in_stub (info, &l->group_statement.children.head);
 187           if (ret)
 188             return ret;
 189           break;
 190
 191         case lang_input_section_enum:
 192           if (l->input_section.section == info->input_section)
 193             {
 194               /* We've found our section.  Insert the stub immediately
 195                  before its associated input section.  */
 196               *lp = info->add.head;
 197               *(info->add.tail) = l;
 198               return TRUE;
 199             }
 200           break;
 201
 202         case lang_data_statement_enum:
 203         case lang_reloc_statement_enum:
 204         case lang_object_symbols_statement_enum:
 205         case lang_output_statement_enum:
 206         case lang_target_statement_enum:
 207         case lang_input_statement_enum:
 208         case lang_assignment_statement_enum:
 209         case lang_padding_statement_enum:
 210         case lang_address_statement_enum:
 211         case lang_fill_statement_enum:
 212           break;
 213
 214         default:
 215           FAIL ();
 216           break;
 217         }
 218     }
 219   return FALSE;
 220 }
 221
 222
 223 /* Call-back for ppc64_elf_size_stubs.  */
 224
 225 /* Create a new stub section, and arrange for it to be linked
 226    immediately before INPUT_SECTION.  */
 227
 228 static asection *
 229 ppc_add_stub_section (stub_sec_name, input_section)
 230      const char *stub_sec_name;
 231      asection *input_section;
 232 {
 233   asection *stub_sec;
 234   flagword flags;
 235   asection *output_section;
 236   const char *secname;
 237   lang_output_section_statement_type *os;
 238   struct hook_stub_info info;
 239
 240   stub_sec = bfd_make_section_anyway (stub_file->the_bfd, stub_sec_name);
 241   if (stub_sec == NULL)
 242     goto err_ret;
 243
 244   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE
 245            | SEC_HAS_CONTENTS | SEC_RELOC | SEC_IN_MEMORY | SEC_KEEP);
 246   if (!bfd_set_section_flags (stub_file->the_bfd, stub_sec, flags))
 247     goto err_ret;
 248
 249   output_section = input_section->output_section;
 250   secname = bfd_get_section_name (output_section->owner, output_section);
 251   os = lang_output_section_find (secname);
 252
 253   info.input_section = input_section;
 254   lang_list_init (&info.add);
 255   lang_add_section (&info.add, stub_sec, os, stub_file);
 256
 257   if (info.add.head == NULL)
 258     goto err_ret;
 259
 260   if (hook_in_stub (&info, &os->children.head))
 261     return stub_sec;
 262
 263  err_ret:
 264   einfo ("%X%P: can not make stub section: %E\n");
 265   return NULL;
 266 }
 267
 268
 269 /* Another call-back for ppc64_elf_size_stubs.  */
 270
 271 static void
 272 ppc_layout_sections_again ()
 273 {
 274   /* If we have changed sizes of the stub sections, then we need
 275      to recalculate all the section offsets.  This may mean we need to
 276      add even more stubs.  */
 277   need_laying_out = 0;
 278
 279   lang_reset_memory_regions ();
 280
 281   /* Resize the sections.  */
 282   lang_size_sections (stat_ptr->head, abs_output_section,
 283                       &stat_ptr->head, 0, (bfd_vma) 0, NULL, TRUE);
 284
 285   /* Recalculate TOC base.  */
 286   ldemul_after_allocation ();
 287
 288   /* Do the assignments again.  */
 289   lang_do_assignments (stat_ptr->head, abs_output_section,
 290                        (fill_type *) 0, (bfd_vma) 0);
 291 }
 292
 293
 294 /* Call the back-end function to set TOC base after we have placed all
 295    the sections.  */
 296 static void
 297 gld${EMULATION_NAME}_after_allocation ()
 298 {
 299   if (!link_info.relocateable)
 300     _bfd_set_gp_value (output_bfd, ppc64_elf_toc (output_bfd));
 301 }
 302
 303
 304 static void
 305 build_toc_list (statement)
 306      lang_statement_union_type *statement;
 307 {
 308   if (statement->header.type == lang_input_section_enum
 309       && !statement->input_section.ifile->just_syms_flag
 310       && statement->input_section.section->output_section == toc_section)
 311     {
 312       ppc64_elf_next_toc_section (&link_info, statement->input_section.section);
 313     }
 314 }
 315
 316
 317 static void
 318 build_section_lists (statement)
 319      lang_statement_union_type *statement;
 320 {
 321   if (statement->header.type == lang_input_section_enum
 322       && !statement->input_section.ifile->just_syms_flag
 323       && statement->input_section.section->output_section != NULL
 324       && statement->input_section.section->output_section->owner == output_bfd)
 325     {
 326       if (!ppc64_elf_next_input_section (&link_info,
 327                                          statement->input_section.section))
 328         einfo ("%X%P: can not size stub section: %E\n");
 329     }
 330 }
 331
 332
 333 /* Final emulation specific call.  */
 334
 335 static void
 336 gld${EMULATION_NAME}_finish ()
 337 {
 338   /* e_entry on PowerPC64 points to the function descriptor for
 339      _start.  If _start is missing, default to the first function
 340      descriptor in the .opd section.  */
 341   entry_section = ".opd";
 342
 343   /* bfd_elf64_discard_info just plays with debugging sections,
 344      ie. doesn't affect any code, so we can delay resizing the
 345      sections.  It's likely we'll resize everything in the process of
 346      adding stubs.  */
 347   if (bfd_elf${ELFSIZE}_discard_info (output_bfd, &link_info))
 348     need_laying_out = 1;
 349
 350   /* If generating a relocatable output file, then we don't have any
 351      stubs.  */
 352   if (stub_file != NULL && !link_info.relocateable)
 353     {
 354       int ret = ppc64_elf_setup_section_lists (output_bfd, &link_info);
 355       if (ret != 0)
 356         {
 357           if (ret < 0)
 358             {
 359               einfo ("%X%P: can not size stub section: %E\n");
 360               return;
 361             }
 362
 363           toc_section = bfd_get_section_by_name (output_bfd, ".toc");
 364           if (toc_section != NULL)
 365             lang_for_each_statement (build_toc_list);
 366
 367           ppc64_elf_reinit_toc (output_bfd, &link_info);
 368
 369           lang_for_each_statement (build_section_lists);
 370
 371           /* Call into the BFD backend to do the real work.  */
 372           if (!ppc64_elf_size_stubs (output_bfd,
 373                                      stub_file->the_bfd,
 374                                      &link_info,
 375                                      group_size,
 376                                      &ppc_add_stub_section,
 377                                      &ppc_layout_sections_again))
 378             {
 379               einfo ("%X%P: can not size stub section: %E\n");
 380               return;
 381             }
 382         }
 383     }
 384
 385   if (need_laying_out)
 386     ppc_layout_sections_again ();
 387
 388   if (stub_file != NULL && stub_file->the_bfd->sections != NULL)
 389     {
 390       if (!ppc64_elf_build_stubs (emit_stub_syms, &link_info))
 391         einfo ("%X%P: can not build stubs: %E\n");
 392     }
 393 }
 394
 395
 396 /* Add a pattern matching ".foo" for every "foo" in a version script.
 397
 398    The reason for doing this is that many shared library version
 399    scripts export a selected set of functions or data symbols, forcing
 400    others local.  eg.
 401
 402    . VERS_1 {
 403    .       global:
 404    .               this; that; some; thing;
 405    .       local:
 406    .               *;
 407    .   };
 408
 409    To make the above work for PowerPC64, we need to export ".this",
 410    ".that" and so on, otherwise only the function descriptor syms are
 411    exported.  Lack of an exported function code sym may cause a
 412    definition to be pulled in from a static library.  */
 413
 414 struct bfd_elf_version_expr *
 415 gld${EMULATION_NAME}_new_vers_pattern (entry)
 416      struct bfd_elf_version_expr *entry;
 417 {
 418   struct bfd_elf_version_expr *dot_entry;
 419   struct bfd_elf_version_expr *next;
 420   unsigned int len;
 421   char *dot_pat;
 422
 423   if (!dotsyms || entry->pattern[0] == '*')
 424     return entry;
 425
 426   /* Is the script adding ".foo" explicitly?  */
 427   if (entry->pattern[0] == '.')
 428     {
 429       /* We may have added this pattern automatically.  Don't add it
 430          again.  Quadratic behaviour here is acceptable as the list
 431          may be traversed for each input bfd symbol.  */
 432       for (next = entry->next; next != NULL; next = next->next)
 433         {
 434           if (strcmp (next->pattern, entry->pattern) == 0
 435               && next->match == entry->match)
 436             {
 437               next = entry->next;
 438               free ((char *) entry->pattern);
 439               free (entry);
 440               return next;
 441             }
 442         }
 443       return entry;
 444     }
 445
 446   /* Don't add ".foo" if the script has already done so.  */
 447   for (next = entry->next; next != NULL; next = next->next)
 448     {
 449       if (next->pattern[0] == '.'
 450           && strcmp (next->pattern + 1, entry->pattern) == 0
 451           && next->match == entry->match)
 452         return entry;
 453     }
 454
 455   dot_entry = (struct bfd_elf_version_expr *) xmalloc (sizeof *dot_entry);
 456   dot_entry->next = entry;
 457   len = strlen (entry->pattern) + 2;
 458   dot_pat = xmalloc (len);
 459   dot_pat[0] = '.';
 460   memcpy (dot_pat + 1, entry->pattern, len - 1);
 461   dot_entry->pattern = dot_pat;
 462   dot_entry->match = entry->match;
 463   return dot_entry;
 464 }
 465
 466
 467 /* Avoid processing the fake stub_file in vercheck, stat_needed and
 468    check_needed routines.  */
 469
 470 static void ppc_for_each_input_file_wrapper
 471   PARAMS ((lang_input_statement_type *));
 472 static void ppc_lang_for_each_input_file
 473   PARAMS ((void (*) (lang_input_statement_type *)));
 474
 475 static void (*real_func) PARAMS ((lang_input_statement_type *));
 476
 477 static void ppc_for_each_input_file_wrapper (l)
 478      lang_input_statement_type *l;
 479 {
 480   if (l != stub_file)
 481     (*real_func) (l);
 482 }
 483
 484 static void
 485 ppc_lang_for_each_input_file (func)
 486      void (*func) PARAMS ((lang_input_statement_type *));
 487 {
 488   real_func = func;
 489   lang_for_each_input_file (&ppc_for_each_input_file_wrapper);
 490 }
 491
 492 #define lang_for_each_input_file ppc_lang_for_each_input_file
 493
 494 EOF
 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_DOTSYMS                  (OPTION_STUBSYMS + 1)
 503 #define OPTION_NO_DOTSYMS               (OPTION_DOTSYMS + 1)
 504 #define OPTION_NO_TLS_OPT               (OPTION_NO_DOTSYMS + 1)
 505 '
 506
 507 PARSE_AND_LIST_LONGOPTS='
 508   { "stub-group-size", required_argument, NULL, OPTION_STUBGROUP_SIZE },
 509   { "emit-stub-syms", no_argument, NULL, OPTION_STUBSYMS },
 510   { "dotsyms", no_argument, NULL, OPTION_DOTSYMS },
 511   { "no-dotsyms", no_argument, NULL, OPTION_NO_DOTSYMS },
 512   { "no-tls-optimize", no_argument, NULL, OPTION_NO_TLS_OPT },
 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 '
 541
 542 PARSE_AND_LIST_ARGS_CASES='
 543     case OPTION_STUBGROUP_SIZE:
 544       {
 545         const char *end;
 546         group_size = bfd_scan_vma (optarg, &end, 0);
 547         if (*end)
 548           einfo (_("%P%F: invalid number `%s'\''\n"), optarg);
 549       }
 550       break;
 551
 552     case OPTION_STUBSYMS:
 553       emit_stub_syms = 1;
 554       break;
 555
 556     case OPTION_DOTSYMS:
 557       dotsyms = 1;
 558       break;
 559
 560     case OPTION_NO_DOTSYMS:
 561       dotsyms = 0;
 562       break;
 563
 564     case OPTION_NO_TLS_OPT:
 565       notlsopt = 1;
 566       break;
 567 '
 568
 569 # Put these extra ppc64elf routines in ld_${EMULATION_NAME}_emulation
 570 #
 571 LDEMUL_AFTER_OPEN=ppc_after_open
 572 LDEMUL_BEFORE_ALLOCATION=ppc_before_allocation
 573 LDEMUL_AFTER_ALLOCATION=gld${EMULATION_NAME}_after_allocation
 574 LDEMUL_FINISH=gld${EMULATION_NAME}_finish
 575 LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS=ppc_create_output_section_statements
 576 LDEMUL_NEW_VERS_PATTERN=gld${EMULATION_NAME}_new_vers_pattern