ld/emultempl/hppaelf.em

   1 # This shell script emits a C file. -*- C -*-
   2 #   Copyright 1991, 1993, 1994, 1997, 1999, 2000, 2001, 2002
   3 #   Free Software Foundation, Inc.
   4 #
   5 # This file is part of GLD, the Gnu Linker.
   6 #
   7 # This program is free software; you can redistribute it and/or modify
   8 # it under the terms of the GNU General Public License as published by
   9 # the Free Software Foundation; either version 2 of the License, or
  10 # (at your option) any later version.
  11 #
  12 # This program is distributed in the hope that it will be useful,
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 # GNU General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU General Public License
  18 # along with this program; if not, write to the Free Software
  19 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  20 #
  21
  22 # This file is sourced from elf32.em, and defines extra hppa-elf
  23 # specific routines.
  24 #
  25 cat >>e${EMULATION_NAME}.c <<EOF
  26
  27 #include "ldctor.h"
  28 #include "elf32-hppa.h"
  29
  30 static void hppaelf_after_parse PARAMS((void));
  31 static void hppaelf_create_output_section_statements PARAMS ((void));
  32 static asection *hppaelf_add_stub_section
  33   PARAMS ((const char *, asection *));
  34 static void hppaelf_layout_sections_again PARAMS ((void));
  35 static void gld${EMULATION_NAME}_finish PARAMS ((void));
  36 static void build_section_lists PARAMS ((lang_statement_union_type *));
  37
  38
  39 /* Fake input file for stubs.  */
  40 static lang_input_statement_type *stub_file;
  41
  42 /* Type of import/export stubs to build.  For a single sub-space model,
  43    we can build smaller import stubs and there is no need for export
  44    stubs.  */
  45 static int multi_subspace = 0;
  46
  47 /* Whether we need to call hppa_layout_sections_again.  */
  48 static int need_laying_out = 0;
  49
  50 /* Maximum size of a group of input sections that can be handled by
  51    one stub section.  A value of +/-1 indicates the bfd back-end
  52    should use a suitable default size.  */
  53 static bfd_signed_vma group_size = 1;
  54
  55 /* Stops the linker merging .text sections on a relocatable link,
  56    and adds millicode library to the list of input files.  */
  57
  58 static void
  59 hppaelf_after_parse ()
  60 {
  61   if (link_info.relocateable)
  62     lang_add_unique (".text");
  63 #if 0 /* enable this once we split millicode stuff from libgcc */
  64   else
  65     lang_add_input_file ("milli",
  66                          lang_input_file_is_l_enum,
  67                          NULL);
  68 #endif
  69 }
  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 hppaelf_create_output_section_statements ()
  76 {
  77   stub_file = lang_add_input_file ("linker stubs",
  78                                    lang_input_file_is_fake_enum,
  79                                    NULL);
  80   stub_file->the_bfd = bfd_create ("linker stubs", output_bfd);
  81   if (stub_file->the_bfd == NULL
  82       || ! bfd_set_arch_mach (stub_file->the_bfd,
  83                               bfd_get_arch (output_bfd),
  84                               bfd_get_mach (output_bfd)))
  85     {
  86       einfo ("%X%P: can not create BFD %E\n");
  87       return;
  88     }
  89
  90   ldlang_add_file (stub_file);
  91 }
  92
  93
  94 struct hook_stub_info
  95 {
  96   lang_statement_list_type add;
  97   asection *input_section;
  98 };
  99
 100 /* Traverse the linker tree to find the spot where the stub goes.  */
 101
 102 static boolean hook_in_stub
 103   PARAMS ((struct hook_stub_info *, lang_statement_union_type **));
 104
 105 static boolean
 106 hook_in_stub (info, lp)
 107      struct hook_stub_info *info;
 108      lang_statement_union_type **lp;
 109 {
 110   lang_statement_union_type *l;
 111   boolean ret;
 112
 113   for (; (l = *lp) != NULL; lp = &l->header.next)
 114     {
 115       switch (l->header.type)
 116         {
 117         case lang_constructors_statement_enum:
 118           ret = hook_in_stub (info, &constructor_list.head);
 119           if (ret)
 120             return ret;
 121           break;
 122
 123         case lang_output_section_statement_enum:
 124           ret = hook_in_stub (info,
 125                               &l->output_section_statement.children.head);
 126           if (ret)
 127             return ret;
 128           break;
 129
 130         case lang_wild_statement_enum:
 131           ret = hook_in_stub (info, &l->wild_statement.children.head);
 132           if (ret)
 133             return ret;
 134           break;
 135
 136         case lang_group_statement_enum:
 137           ret = hook_in_stub (info, &l->group_statement.children.head);
 138           if (ret)
 139             return ret;
 140           break;
 141
 142         case lang_input_section_enum:
 143           if (l->input_section.section == info->input_section)
 144             {
 145               /* We've found our section.  Insert the stub immediately
 146                  before its associated input section.  */
 147               *lp = info->add.head;
 148               *(info->add.tail) = l;
 149               return true;
 150             }
 151           break;
 152
 153         case lang_data_statement_enum:
 154         case lang_reloc_statement_enum:
 155         case lang_object_symbols_statement_enum:
 156         case lang_output_statement_enum:
 157         case lang_target_statement_enum:
 158         case lang_input_statement_enum:
 159         case lang_assignment_statement_enum:
 160         case lang_padding_statement_enum:
 161         case lang_address_statement_enum:
 162         case lang_fill_statement_enum:
 163           break;
 164
 165         default:
 166           FAIL ();
 167           break;
 168         }
 169     }
 170   return false;
 171 }
 172
 173
 174 /* Call-back for elf32_hppa_size_stubs.  */
 175
 176 /* Create a new stub section, and arrange for it to be linked
 177    immediately before INPUT_SECTION.  */
 178
 179 static asection *
 180 hppaelf_add_stub_section (stub_sec_name, input_section)
 181      const char *stub_sec_name;
 182      asection *input_section;
 183 {
 184   asection *stub_sec;
 185   flagword flags;
 186   asection *output_section;
 187   const char *secname;
 188   lang_output_section_statement_type *os;
 189   struct hook_stub_info info;
 190
 191   stub_sec = bfd_make_section_anyway (stub_file->the_bfd, stub_sec_name);
 192   if (stub_sec == NULL)
 193     goto err_ret;
 194
 195   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE
 196            | SEC_HAS_CONTENTS | SEC_RELOC | SEC_IN_MEMORY | SEC_KEEP);
 197   if (!bfd_set_section_flags (stub_file->the_bfd, stub_sec, flags))
 198     goto err_ret;
 199
 200   output_section = input_section->output_section;
 201   secname = bfd_get_section_name (output_section->owner, output_section);
 202   os = lang_output_section_find (secname);
 203
 204   info.input_section = input_section;
 205   lang_list_init (&info.add);
 206   lang_add_section (&info.add, stub_sec, os, stub_file);
 207
 208   if (info.add.head == NULL)
 209     goto err_ret;
 210
 211   if (hook_in_stub (&info, &os->children.head))
 212     return stub_sec;
 213
 214  err_ret:
 215   einfo ("%X%P: can not make stub section: %E\n");
 216   return NULL;
 217 }
 218
 219
 220 /* Another call-back for elf32_hppa_size_stubs.  */
 221
 222 static void
 223 hppaelf_layout_sections_again ()
 224 {
 225   /* If we have changed sizes of the stub sections, then we need
 226      to recalculate all the section offsets.  This may mean we need to
 227      add even more stubs.  */
 228   need_laying_out = 0;
 229
 230   lang_reset_memory_regions ();
 231
 232   /* Resize the sections.  */
 233   lang_size_sections (stat_ptr->head, abs_output_section,
 234                       &stat_ptr->head, 0, (bfd_vma) 0, NULL);
 235
 236   /* Redo special stuff.  */
 237   ldemul_after_allocation ();
 238
 239   /* Do the assignments again.  */
 240   lang_do_assignments (stat_ptr->head, abs_output_section,
 241                        (fill_type *) 0, (bfd_vma) 0);
 242 }
 243
 244
 245 static void
 246 build_section_lists (statement)
 247      lang_statement_union_type *statement;
 248 {
 249   if (statement->header.type == lang_input_section_enum
 250       && !statement->input_section.ifile->just_syms_flag
 251       && statement->input_section.section->output_section != NULL
 252       && statement->input_section.section->output_section->owner == output_bfd)
 253     {
 254       elf32_hppa_next_input_section (&link_info,
 255                                      statement->input_section.section);
 256     }
 257 }
 258
 259
 260 /* Final emulation specific call.  For the PA we use this opportunity
 261    to build linker stubs.  */
 262
 263 static void
 264 gld${EMULATION_NAME}_finish ()
 265 {
 266   int ret;
 267
 268   /* If generating a relocatable output file, then we don't
 269      have to examine the relocs.  */
 270   if (link_info.relocateable)
 271     return;
 272
 273   /* bfd_elf32_discard_info just plays with debugging sections,
 274      ie. doesn't affect any code, so we can delay resizing the
 275      sections.  It's likely we'll resize everything in the process of
 276      adding stubs.  */
 277   if (bfd_elf${ELFSIZE}_discard_info (output_bfd, &link_info))
 278     need_laying_out = 1;
 279
 280   ret = elf32_hppa_setup_section_lists (output_bfd, &link_info);
 281   if (ret != 0)
 282     {
 283       if (ret < 0)
 284         {
 285           einfo ("%X%P: can not size stub section: %E\n");
 286           return;
 287         }
 288
 289       lang_for_each_statement (build_section_lists);
 290
 291       /* Call into the BFD backend to do the real work.  */
 292       if (! elf32_hppa_size_stubs (output_bfd,
 293                                    stub_file->the_bfd,
 294                                    &link_info,
 295                                    multi_subspace,
 296                                    group_size,
 297                                    &hppaelf_add_stub_section,
 298                                    &hppaelf_layout_sections_again))
 299         {
 300           einfo ("%X%P: can not size stub section: %E\n");
 301           return;
 302         }
 303     }
 304
 305   if (need_laying_out)
 306     hppaelf_layout_sections_again ();
 307
 308   /* Set the global data pointer.  */
 309   if (! elf32_hppa_set_gp (output_bfd, &link_info))
 310     {
 311       einfo ("%X%P: can not set gp\n");
 312       return;
 313     }
 314
 315   /* Now build the linker stubs.  */
 316   if (stub_file->the_bfd->sections != NULL)
 317     {
 318       if (! elf32_hppa_build_stubs (&link_info))
 319         einfo ("%X%P: can not build stubs: %E\n");
 320     }
 321 }
 322
 323
 324 /* Avoid processing the fake stub_file in vercheck, stat_needed and
 325    check_needed routines.  */
 326
 327 static void hppa_for_each_input_file_wrapper
 328   PARAMS ((lang_input_statement_type *));
 329 static void hppa_lang_for_each_input_file
 330   PARAMS ((void (*) (lang_input_statement_type *)));
 331
 332 static void (*real_func) PARAMS ((lang_input_statement_type *));
 333
 334 static void hppa_for_each_input_file_wrapper (l)
 335      lang_input_statement_type *l;
 336 {
 337   if (l != stub_file)
 338     (*real_func) (l);
 339 }
 340
 341 static void
 342 hppa_lang_for_each_input_file (func)
 343      void (*func) PARAMS ((lang_input_statement_type *));
 344 {
 345   real_func = func;
 346   lang_for_each_input_file (&hppa_for_each_input_file_wrapper);
 347 }
 348
 349 #define lang_for_each_input_file hppa_lang_for_each_input_file
 350
 351 EOF
 352
 353 # Define some shell vars to insert bits of code into the standard elf
 354 # parse_args and list_options functions.
 355 #
 356 PARSE_AND_LIST_PROLOGUE='
 357 #define OPTION_MULTI_SUBSPACE           301
 358 #define OPTION_STUBGROUP_SIZE           (OPTION_MULTI_SUBSPACE + 1)
 359 '
 360
 361 # The options are repeated below so that no abbreviations are allowed.
 362 # Otherwise -s matches stub-group-size
 363 PARSE_AND_LIST_LONGOPTS='
 364   { "multi-subspace", no_argument, NULL, OPTION_MULTI_SUBSPACE },
 365   { "multi-subspace", no_argument, NULL, OPTION_MULTI_SUBSPACE },
 366   { "stub-group-size", required_argument, NULL, OPTION_STUBGROUP_SIZE },
 367   { "stub-group-size", required_argument, NULL, OPTION_STUBGROUP_SIZE },
 368 '
 369
 370 PARSE_AND_LIST_OPTIONS='
 371   fprintf (file, _("\
 372   --multi-subspace      Generate import and export stubs to support\n\
 373                           multiple sub-space shared libraries\n"
 374                    ));
 375   fprintf (file, _("\
 376   --stub-group-size=N   Maximum size of a group of input sections that can be\n\
 377                           handled by one stub section.  A negative value\n\
 378                           locates all stubs before their branches (with a\n\
 379                           group size of -N), while a positive value allows\n\
 380                           two groups of input sections, one before, and one\n\
 381                           after each stub section.  Values of +/-1 indicate\n\
 382                           the linker should choose suitable defaults.\n"
 383                    ));
 384 '
 385
 386 PARSE_AND_LIST_ARGS_CASES='
 387     case OPTION_MULTI_SUBSPACE:
 388       multi_subspace = 1;
 389       break;
 390
 391     case OPTION_STUBGROUP_SIZE:
 392       {
 393         const char *end;
 394         group_size = bfd_scan_vma (optarg, &end, 0);
 395         if (*end)
 396           einfo (_("%P%F: invalid number `%s'\''\n"), optarg);
 397       }
 398       break;
 399 '
 400
 401 # Put these extra hppaelf routines in ld_${EMULATION_NAME}_emulation
 402 #
 403 LDEMUL_AFTER_PARSE=hppaelf_after_parse
 404 LDEMUL_FINISH=gld${EMULATION_NAME}_finish
 405 LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS=hppaelf_create_output_section_statements