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