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 static void ppc_create_output_section_statements
  48   PARAMS ((void));
  49 static void ppc_after_open
  50   PARAMS ((void));
  51 static void ppc_before_allocation
  52   PARAMS ((void));
  53 static asection *ppc_add_stub_section
  54   PARAMS ((const char *, asection *));
  55 static void ppc_layout_sections_again
  56   PARAMS ((void));
  57 static void gld${EMULATION_NAME}_after_allocation
  58   PARAMS ((void));
  59 static void build_section_lists
  60   PARAMS ((lang_statement_union_type *));
  61 static struct bfd_elf_version_expr *gld${EMULATION_NAME}_new_vers_pattern
  62   PARAMS ((struct bfd_elf_version_expr *));
  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 ()
  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   stub_file = lang_add_input_file ("linker stubs",
  78                                    lang_input_file_is_fake_enum,
  79                                    NULL);
  80   stub_file->the_bfd = bfd_create ("linker stubs", output_bfd);
  81   if (stub_file->the_bfd == NULL
  82       || !bfd_set_arch_mach (stub_file->the_bfd,
  83                              bfd_get_arch (output_bfd),
  84                              bfd_get_mach (output_bfd)))
  85     {
  86       einfo ("%X%P: can not create BFD %E\n");
  87       return;
  88     }
  89
  90   ldlang_add_file (stub_file);
  91 }
  92
  93 static void
  94 ppc_after_open ()
  95 {
  96   if (!ppc64_elf_mark_entry_syms (&link_info))
  97     {
  98       einfo ("%X%P: can not mark entry symbols %E\n");
  99       return;
 100     }
 101
 102   gld${EMULATION_NAME}_after_open ();
 103 }
 104
 105 static void
 106 ppc_before_allocation ()
 107 {
 108   if (stub_file != NULL)
 109     {
 110       if (!ppc64_elf_edit_opd (output_bfd, &link_info))
 111         {
 112           einfo ("%X%P: can not edit opd %E\n");
 113           return;
 114         }
 115
 116       if (ppc64_elf_tls_setup (output_bfd, &link_info) && !notlsopt)
 117         {
 118           /* Size the sections.  This is premature, but we want to know the
 119              TLS segment layout so that certain optimizations can be done.  */
 120           lang_size_sections (stat_ptr->head, abs_output_section,
 121                               &stat_ptr->head, 0, (bfd_vma) 0, NULL, TRUE);
 122
 123           if (!ppc64_elf_tls_optimize (output_bfd, &link_info))
 124             {
 125               einfo ("%X%P: TLS problem %E\n");
 126               return;
 127             }
 128
 129           lang_reset_memory_regions ();
 130         }
 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 hook_in_stub
 145   PARAMS ((struct hook_stub_info *, lang_statement_union_type **));
 146
 147 static bfd_boolean
 148 hook_in_stub (info, lp)
 149      struct hook_stub_info *info;
 150      lang_statement_union_type **lp;
 151 {
 152   lang_statement_union_type *l;
 153   bfd_boolean ret;
 154
 155   for (; (l = *lp) != NULL; lp = &l->header.next)
 156     {
 157       switch (l->header.type)
 158         {
 159         case lang_constructors_statement_enum:
 160           ret = hook_in_stub (info, &constructor_list.head);
 161           if (ret)
 162             return ret;
 163           break;
 164
 165         case lang_output_section_statement_enum:
 166           ret = hook_in_stub (info,
 167                               &l->output_section_statement.children.head);
 168           if (ret)
 169             return ret;
 170           break;
 171
 172         case lang_wild_statement_enum:
 173           ret = hook_in_stub (info, &l->wild_statement.children.head);
 174           if (ret)
 175             return ret;
 176           break;
 177
 178         case lang_group_statement_enum:
 179           ret = hook_in_stub (info, &l->group_statement.children.head);
 180           if (ret)
 181             return ret;
 182           break;
 183
 184         case lang_input_section_enum:
 185           if (l->input_section.section == info->input_section)
 186             {
 187               /* We've found our section.  Insert the stub immediately
 188                  before its associated input section.  */
 189               *lp = info->add.head;
 190               *(info->add.tail) = l;
 191               return TRUE;
 192             }
 193           break;
 194
 195         case lang_data_statement_enum:
 196         case lang_reloc_statement_enum:
 197         case lang_object_symbols_statement_enum:
 198         case lang_output_statement_enum:
 199         case lang_target_statement_enum:
 200         case lang_input_statement_enum:
 201         case lang_assignment_statement_enum:
 202         case lang_padding_statement_enum:
 203         case lang_address_statement_enum:
 204         case lang_fill_statement_enum:
 205           break;
 206
 207         default:
 208           FAIL ();
 209           break;
 210         }
 211     }
 212   return FALSE;
 213 }
 214
 215
 216 /* Call-back for ppc64_elf_size_stubs.  */
 217
 218 /* Create a new stub section, and arrange for it to be linked
 219    immediately before INPUT_SECTION.  */
 220
 221 static asection *
 222 ppc_add_stub_section (stub_sec_name, input_section)
 223      const char *stub_sec_name;
 224      asection *input_section;
 225 {
 226   asection *stub_sec;
 227   flagword flags;
 228   asection *output_section;
 229   const char *secname;
 230   lang_output_section_statement_type *os;
 231   struct hook_stub_info info;
 232
 233   stub_sec = bfd_make_section_anyway (stub_file->the_bfd, stub_sec_name);
 234   if (stub_sec == NULL)
 235     goto err_ret;
 236
 237   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE
 238            | SEC_HAS_CONTENTS | SEC_RELOC | SEC_IN_MEMORY | SEC_KEEP);
 239   if (!bfd_set_section_flags (stub_file->the_bfd, stub_sec, flags))
 240     goto err_ret;
 241
 242   output_section = input_section->output_section;
 243   secname = bfd_get_section_name (output_section->owner, output_section);
 244   os = lang_output_section_find (secname);
 245
 246   info.input_section = input_section;
 247   lang_list_init (&info.add);
 248   lang_add_section (&info.add, stub_sec, os, stub_file);
 249
 250   if (info.add.head == NULL)
 251     goto err_ret;
 252
 253   if (hook_in_stub (&info, &os->children.head))
 254     return stub_sec;
 255
 256  err_ret:
 257   einfo ("%X%P: can not make stub section: %E\n");
 258   return NULL;
 259 }
 260
 261
 262 /* Another call-back for ppc64_elf_size_stubs.  */
 263
 264 static void
 265 ppc_layout_sections_again ()
 266 {
 267   /* If we have changed sizes of the stub sections, then we need
 268      to recalculate all the section offsets.  This may mean we need to
 269      add even more stubs.  */
 270   need_laying_out = 0;
 271
 272   lang_reset_memory_regions ();
 273
 274   /* Resize the sections.  */
 275   lang_size_sections (stat_ptr->head, abs_output_section,
 276                       &stat_ptr->head, 0, (bfd_vma) 0, NULL, TRUE);
 277
 278   /* Recalculate TOC base.  */
 279   ldemul_after_allocation ();
 280
 281   /* Do the assignments again.  */
 282   lang_do_assignments (stat_ptr->head, abs_output_section,
 283                        (fill_type *) 0, (bfd_vma) 0);
 284 }
 285
 286
 287 /* Call the back-end function to set TOC base after we have placed all
 288    the sections.  */
 289 static void
 290 gld${EMULATION_NAME}_after_allocation ()
 291 {
 292   if (!link_info.relocateable)
 293     _bfd_set_gp_value (output_bfd, ppc64_elf_toc (output_bfd));
 294 }
 295
 296
 297 static void
 298 build_section_lists (statement)
 299      lang_statement_union_type *statement;
 300 {
 301   if (statement->header.type == lang_input_section_enum
 302       && !statement->input_section.ifile->just_syms_flag
 303       && statement->input_section.section->output_section != NULL
 304       && statement->input_section.section->output_section->owner == output_bfd)
 305     {
 306       ppc64_elf_next_input_section (&link_info,
 307                                     statement->input_section.section);
 308     }
 309 }
 310
 311
 312 /* Final emulation specific call.  */
 313
 314 static void
 315 gld${EMULATION_NAME}_finish ()
 316 {
 317   /* e_entry on PowerPC64 points to the function descriptor for
 318      _start.  If _start is missing, default to the first function
 319      descriptor in the .opd section.  */
 320   entry_section = ".opd";
 321
 322   /* bfd_elf64_discard_info just plays with debugging sections,
 323      ie. doesn't affect any code, so we can delay resizing the
 324      sections.  It's likely we'll resize everything in the process of
 325      adding stubs.  */
 326   if (bfd_elf${ELFSIZE}_discard_info (output_bfd, &link_info))
 327     need_laying_out = 1;
 328
 329   /* If generating a relocatable output file, then we don't have any
 330      stubs.  */
 331   if (stub_file != NULL && !link_info.relocateable)
 332     {
 333       int ret = ppc64_elf_setup_section_lists (output_bfd, &link_info);
 334       if (ret != 0)
 335         {
 336           if (ret < 0)
 337             {
 338               einfo ("%X%P: can not size stub section: %E\n");
 339               return;
 340             }
 341
 342           lang_for_each_statement (build_section_lists);
 343
 344           /* Call into the BFD backend to do the real work.  */
 345           if (!ppc64_elf_size_stubs (output_bfd,
 346                                      stub_file->the_bfd,
 347                                      &link_info,
 348                                      group_size,
 349                                      &ppc_add_stub_section,
 350                                      &ppc_layout_sections_again))
 351             {
 352               einfo ("%X%P: can not size stub section: %E\n");
 353               return;
 354             }
 355         }
 356     }
 357
 358   if (need_laying_out)
 359     ppc_layout_sections_again ();
 360
 361   if (stub_file != NULL && stub_file->the_bfd->sections != NULL)
 362     {
 363       if (!ppc64_elf_build_stubs (&link_info))
 364         einfo ("%X%P: can not build stubs: %E\n");
 365     }
 366 }
 367
 368
 369 /* Add a pattern matching ".foo" for every "foo" in a version script.
 370
 371    The reason for doing this is that many shared library version
 372    scripts export a selected set of functions or data symbols, forcing
 373    others local.  eg.
 374
 375    . VERS_1 {
 376    .       global:
 377    .               this; that; some; thing;
 378    .       local:
 379    .               *;
 380    .   };
 381
 382    To make the above work for PowerPC64, we need to export ".this",
 383    ".that" and so on, otherwise only the function descriptor syms are
 384    exported.  Lack of an exported function code sym may cause a
 385    definition to be pulled in from a static library.  */
 386
 387 struct bfd_elf_version_expr *
 388 gld${EMULATION_NAME}_new_vers_pattern (entry)
 389      struct bfd_elf_version_expr *entry;
 390 {
 391   struct bfd_elf_version_expr *dot_entry;
 392   struct bfd_elf_version_expr *next;
 393   unsigned int len;
 394   char *dot_pat;
 395
 396   if (!dotsyms || entry->pattern[0] == '*')
 397     return entry;
 398
 399   /* Is the script adding ".foo" explicitly?  */
 400   if (entry->pattern[0] == '.')
 401     {
 402       /* We may have added this pattern automatically.  Don't add it
 403          again.  Quadratic behaviour here is acceptable as the list
 404          may be traversed for each input bfd symbol.  */
 405       for (next = entry->next; next != NULL; next = next->next)
 406         {
 407           if (strcmp (next->pattern, entry->pattern) == 0
 408               && next->match == entry->match)
 409             {
 410               next = entry->next;
 411               free ((char *) entry->pattern);
 412               free (entry);
 413               return next;
 414             }
 415         }
 416       return entry;
 417     }
 418
 419   /* Don't add ".foo" if the script has already done so.  */
 420   for (next = entry->next; next != NULL; next = next->next)
 421     {
 422       if (next->pattern[0] == '.'
 423           && strcmp (next->pattern + 1, entry->pattern) == 0
 424           && next->match == entry->match)
 425         return entry;
 426     }
 427
 428   dot_entry = (struct bfd_elf_version_expr *) xmalloc (sizeof *dot_entry);
 429   dot_entry->next = entry;
 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   dot_entry->match = entry->match;
 436   return dot_entry;
 437 }
 438
 439
 440 /* Avoid processing the fake stub_file in vercheck, stat_needed and
 441    check_needed routines.  */
 442
 443 static void ppc_for_each_input_file_wrapper
 444   PARAMS ((lang_input_statement_type *));
 445 static void ppc_lang_for_each_input_file
 446   PARAMS ((void (*) (lang_input_statement_type *)));
 447
 448 static void (*real_func) PARAMS ((lang_input_statement_type *));
 449
 450 static void ppc_for_each_input_file_wrapper (l)
 451      lang_input_statement_type *l;
 452 {
 453   if (l != stub_file)
 454     (*real_func) (l);
 455 }
 456
 457 static void
 458 ppc_lang_for_each_input_file (func)
 459      void (*func) PARAMS ((lang_input_statement_type *));
 460 {
 461   real_func = func;
 462   lang_for_each_input_file (&ppc_for_each_input_file_wrapper);
 463 }
 464
 465 #define lang_for_each_input_file ppc_lang_for_each_input_file
 466
 467 EOF
 468
 469 # Define some shell vars to insert bits of code into the standard elf
 470 # parse_args and list_options functions.
 471 #
 472 PARSE_AND_LIST_PROLOGUE='
 473 #define OPTION_STUBGROUP_SIZE           301
 474 #define OPTION_DOTSYMS                  (OPTION_STUBGROUP_SIZE + 1)
 475 #define OPTION_NO_DOTSYMS               (OPTION_DOTSYMS + 1)
 476 #define OPTION_NO_TLS_OPT               (OPTION_NO_DOTSYMS + 1)
 477 '
 478
 479 PARSE_AND_LIST_LONGOPTS='
 480   { "stub-group-size", required_argument, NULL, OPTION_STUBGROUP_SIZE },
 481   { "dotsyms", no_argument, NULL, OPTION_DOTSYMS },
 482   { "no-dotsyms", no_argument, NULL, OPTION_NO_DOTSYMS },
 483   { "no-tls-optimize", no_argument, NULL, OPTION_NO_TLS_OPT },
 484 '
 485
 486 PARSE_AND_LIST_OPTIONS='
 487   fprintf (file, _("\
 488   --stub-group-size=N   Maximum size of a group of input sections that can be\n\
 489                           handled by one stub section.  A negative value\n\
 490                           locates all stubs before their branches (with a\n\
 491                           group size of -N), while a positive value allows\n\
 492                           two groups of input sections, one before, and one\n\
 493                           after each stub section.  Values of +/-1 indicate\n\
 494                           the linker should choose suitable defaults.\n"
 495                    ));
 496   fprintf (file, _("\
 497   --dotsyms             For every version pattern \"foo\" in a version script,\n\
 498                           add \".foo\" so that function code symbols are\n\
 499                           treated the same as function descriptor symbols.\n\
 500                           Defaults to on.\n"
 501                    ));
 502   fprintf (file, _("\
 503   --no-dotsyms          Don'\''t do anything special in version scripts.\n"
 504                    ));
 505   fprintf (file, _("\
 506   --no-tls-optimize     Don'\''t try to optimize TLS accesses.\n"
 507                    ));
 508 '
 509
 510 PARSE_AND_LIST_ARGS_CASES='
 511     case OPTION_STUBGROUP_SIZE:
 512       {
 513         const char *end;
 514         group_size = bfd_scan_vma (optarg, &end, 0);
 515         if (*end)
 516           einfo (_("%P%F: invalid number `%s'\''\n"), optarg);
 517       }
 518       break;
 519
 520     case OPTION_DOTSYMS:
 521       dotsyms = 1;
 522       break;
 523
 524     case OPTION_NO_DOTSYMS:
 525       dotsyms = 0;
 526       break;
 527
 528     case OPTION_NO_TLS_OPT:
 529       notlsopt = 1;
 530       break;
 531 '
 532
 533 # Put these extra ppc64elf routines in ld_${EMULATION_NAME}_emulation
 534 #
 535 LDEMUL_AFTER_OPEN=ppc_after_open
 536 LDEMUL_BEFORE_ALLOCATION=ppc_before_allocation
 537 LDEMUL_AFTER_ALLOCATION=gld${EMULATION_NAME}_after_allocation
 538 LDEMUL_FINISH=gld${EMULATION_NAME}_finish
 539 LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS=ppc_create_output_section_statements
 540 LDEMUL_NEW_VERS_PATTERN=gld${EMULATION_NAME}_new_vers_pattern