ld/emultempl/ppc64elf.em

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