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       ppc64_elf_next_input_section (&link_info,
 327                                     statement->input_section.section);
 328     }
 329 }
 330
 331
 332 /* Final emulation specific call.  */
 333
 334 static void
 335 gld${EMULATION_NAME}_finish ()
 336 {
 337   /* e_entry on PowerPC64 points to the function descriptor for
 338      _start.  If _start is missing, default to the first function
 339      descriptor in the .opd section.  */
 340   entry_section = ".opd";
 341
 342   /* bfd_elf64_discard_info just plays with debugging sections,
 343      ie. doesn't affect any code, so we can delay resizing the
 344      sections.  It's likely we'll resize everything in the process of
 345      adding stubs.  */
 346   if (bfd_elf${ELFSIZE}_discard_info (output_bfd, &link_info))
 347     need_laying_out = 1;
 348
 349   /* If generating a relocatable output file, then we don't have any
 350      stubs.  */
 351   if (stub_file != NULL && !link_info.relocateable)
 352     {
 353       int ret = ppc64_elf_setup_section_lists (output_bfd, &link_info);
 354       if (ret != 0)
 355         {
 356           if (ret < 0)
 357             {
 358               einfo ("%X%P: can not size stub section: %E\n");
 359               return;
 360             }
 361
 362           toc_section = bfd_get_section_by_name (output_bfd, ".toc");
 363           if (toc_section != NULL)
 364             lang_for_each_statement (build_toc_list);
 365
 366           ppc64_elf_reinit_toc (output_bfd, &link_info);
 367
 368           lang_for_each_statement (build_section_lists);
 369
 370           /* Call into the BFD backend to do the real work.  */
 371           if (!ppc64_elf_size_stubs (output_bfd,
 372                                      stub_file->the_bfd,
 373                                      &link_info,
 374                                      group_size,
 375                                      &ppc_add_stub_section,
 376                                      &ppc_layout_sections_again))
 377             {
 378               einfo ("%X%P: can not size stub section: %E\n");
 379               return;
 380             }
 381         }
 382     }
 383
 384   if (need_laying_out)
 385     ppc_layout_sections_again ();
 386
 387   if (stub_file != NULL && stub_file->the_bfd->sections != NULL)
 388     {
 389       if (!ppc64_elf_build_stubs (emit_stub_syms, &link_info))
 390         einfo ("%X%P: can not build stubs: %E\n");
 391     }
 392 }
 393
 394
 395 /* Add a pattern matching ".foo" for every "foo" in a version script.
 396
 397    The reason for doing this is that many shared library version
 398    scripts export a selected set of functions or data symbols, forcing
 399    others local.  eg.
 400
 401    . VERS_1 {
 402    .       global:
 403    .               this; that; some; thing;
 404    .       local:
 405    .               *;
 406    .   };
 407
 408    To make the above work for PowerPC64, we need to export ".this",
 409    ".that" and so on, otherwise only the function descriptor syms are
 410    exported.  Lack of an exported function code sym may cause a
 411    definition to be pulled in from a static library.  */
 412
 413 struct bfd_elf_version_expr *
 414 gld${EMULATION_NAME}_new_vers_pattern (entry)
 415      struct bfd_elf_version_expr *entry;
 416 {
 417   struct bfd_elf_version_expr *dot_entry;
 418   struct bfd_elf_version_expr *next;
 419   unsigned int len;
 420   char *dot_pat;
 421
 422   if (!dotsyms || entry->pattern[0] == '*')
 423     return entry;
 424
 425   /* Is the script adding ".foo" explicitly?  */
 426   if (entry->pattern[0] == '.')
 427     {
 428       /* We may have added this pattern automatically.  Don't add it
 429          again.  Quadratic behaviour here is acceptable as the list
 430          may be traversed for each input bfd symbol.  */
 431       for (next = entry->next; next != NULL; next = next->next)
 432         {
 433           if (strcmp (next->pattern, entry->pattern) == 0
 434               && next->match == entry->match)
 435             {
 436               next = entry->next;
 437               free ((char *) entry->pattern);
 438               free (entry);
 439               return next;
 440             }
 441         }
 442       return entry;
 443     }
 444
 445   /* Don't add ".foo" if the script has already done so.  */
 446   for (next = entry->next; next != NULL; next = next->next)
 447     {
 448       if (next->pattern[0] == '.'
 449           && strcmp (next->pattern + 1, entry->pattern) == 0
 450           && next->match == entry->match)
 451         return entry;
 452     }
 453
 454   dot_entry = (struct bfd_elf_version_expr *) xmalloc (sizeof *dot_entry);
 455   dot_entry->next = entry;
 456   len = strlen (entry->pattern) + 2;
 457   dot_pat = xmalloc (len);
 458   dot_pat[0] = '.';
 459   memcpy (dot_pat + 1, entry->pattern, len - 1);
 460   dot_entry->pattern = dot_pat;
 461   dot_entry->match = entry->match;
 462   return dot_entry;
 463 }
 464
 465
 466 /* Avoid processing the fake stub_file in vercheck, stat_needed and
 467    check_needed routines.  */
 468
 469 static void ppc_for_each_input_file_wrapper
 470   PARAMS ((lang_input_statement_type *));
 471 static void ppc_lang_for_each_input_file
 472   PARAMS ((void (*) (lang_input_statement_type *)));
 473
 474 static void (*real_func) PARAMS ((lang_input_statement_type *));
 475
 476 static void ppc_for_each_input_file_wrapper (l)
 477      lang_input_statement_type *l;
 478 {
 479   if (l != stub_file)
 480     (*real_func) (l);
 481 }
 482
 483 static void
 484 ppc_lang_for_each_input_file (func)
 485      void (*func) PARAMS ((lang_input_statement_type *));
 486 {
 487   real_func = func;
 488   lang_for_each_input_file (&ppc_for_each_input_file_wrapper);
 489 }
 490
 491 #define lang_for_each_input_file ppc_lang_for_each_input_file
 492
 493 EOF
 494
 495 # Define some shell vars to insert bits of code into the standard elf
 496 # parse_args and list_options functions.
 497 #
 498 PARSE_AND_LIST_PROLOGUE='
 499 #define OPTION_STUBGROUP_SIZE           301
 500 #define OPTION_STUBSYMS                 (OPTION_STUBGROUP_SIZE + 1)
 501 #define OPTION_DOTSYMS                  (OPTION_STUBSYMS + 1)
 502 #define OPTION_NO_DOTSYMS               (OPTION_DOTSYMS + 1)
 503 #define OPTION_NO_TLS_OPT               (OPTION_NO_DOTSYMS + 1)
 504 '
 505
 506 PARSE_AND_LIST_LONGOPTS='
 507   { "stub-group-size", required_argument, NULL, OPTION_STUBGROUP_SIZE },
 508   { "emit-stub-syms", no_argument, NULL, OPTION_STUBSYMS },
 509   { "dotsyms", no_argument, NULL, OPTION_DOTSYMS },
 510   { "no-dotsyms", no_argument, NULL, OPTION_NO_DOTSYMS },
 511   { "no-tls-optimize", no_argument, NULL, OPTION_NO_TLS_OPT },
 512 '
 513
 514 PARSE_AND_LIST_OPTIONS='
 515   fprintf (file, _("\
 516   --stub-group-size=N   Maximum size of a group of input sections that can be\n\
 517                           handled by one stub section.  A negative value\n\
 518                           locates all stubs before their branches (with a\n\
 519                           group size of -N), while a positive value allows\n\
 520                           two groups of input sections, one before, and one\n\
 521                           after each stub section.  Values of +/-1 indicate\n\
 522                           the linker should choose suitable defaults.\n"
 523                    ));
 524   fprintf (file, _("\
 525   --emit-stub-syms      Label linker stubs with a symbol.\n"
 526                    ));
 527   fprintf (file, _("\
 528   --dotsyms             For every version pattern \"foo\" in a version script,\n\
 529                           add \".foo\" so that function code symbols are\n\
 530                           treated the same as function descriptor symbols.\n\
 531                           Defaults to on.\n"
 532                    ));
 533   fprintf (file, _("\
 534   --no-dotsyms          Don'\''t do anything special in version scripts.\n"
 535                    ));
 536   fprintf (file, _("\
 537   --no-tls-optimize     Don'\''t try to optimize TLS accesses.\n"
 538                    ));
 539 '
 540
 541 PARSE_AND_LIST_ARGS_CASES='
 542     case OPTION_STUBGROUP_SIZE:
 543       {
 544         const char *end;
 545         group_size = bfd_scan_vma (optarg, &end, 0);
 546         if (*end)
 547           einfo (_("%P%F: invalid number `%s'\''\n"), optarg);
 548       }
 549       break;
 550
 551     case OPTION_STUBSYMS:
 552       emit_stub_syms = 1;
 553       break;
 554
 555     case OPTION_DOTSYMS:
 556       dotsyms = 1;
 557       break;
 558
 559     case OPTION_NO_DOTSYMS:
 560       dotsyms = 0;
 561       break;
 562
 563     case OPTION_NO_TLS_OPT:
 564       notlsopt = 1;
 565       break;
 566 '
 567
 568 # Put these extra ppc64elf routines in ld_${EMULATION_NAME}_emulation
 569 #
 570 LDEMUL_AFTER_OPEN=ppc_after_open
 571 LDEMUL_BEFORE_ALLOCATION=ppc_before_allocation
 572 LDEMUL_AFTER_ALLOCATION=gld${EMULATION_NAME}_after_allocation
 573 LDEMUL_FINISH=gld${EMULATION_NAME}_finish
 574 LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS=ppc_create_output_section_statements
 575 LDEMUL_NEW_VERS_PATTERN=gld${EMULATION_NAME}_new_vers_pattern