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