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