ld/emultempl/hppaelf.em

   1 # This shell script emits a C file. -*- C -*-
   2 #   Copyright 1991, 1993, 1994, 1997, 1999, 2000, 2001, 2002, 2003
   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.relocatable)
  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 bfd_boolean hook_in_stub
 103   PARAMS ((struct hook_stub_info *, lang_statement_union_type **));
 104
 105 static bfd_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   bfd_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, TRUE);
 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   /* bfd_elf32_discard_info just plays with debugging sections,
 267      ie. doesn't affect any code, so we can delay resizing the
 268      sections.  It's likely we'll resize everything in the process of
 269      adding stubs.  */
 270   if (bfd_elf${ELFSIZE}_discard_info (output_bfd, &link_info))
 271     need_laying_out = 1;
 272
 273   /* If generating a relocatable output file, then we don't
 274      have to examine the relocs.  */
 275   if (! link_info.relocatable)
 276     {
 277       int ret = elf32_hppa_setup_section_lists (output_bfd, &link_info);
 278
 279       if (ret != 0)
 280         {
 281           if (ret < 0)
 282             {
 283               einfo ("%X%P: can not size stub section: %E\n");
 284               return;
 285             }
 286
 287           lang_for_each_statement (build_section_lists);
 288
 289           /* Call into the BFD backend to do the real work.  */
 290           if (! elf32_hppa_size_stubs (output_bfd,
 291                                        stub_file->the_bfd,
 292                                        &link_info,
 293                                        multi_subspace,
 294                                        group_size,
 295                                        &hppaelf_add_stub_section,
 296                                        &hppaelf_layout_sections_again))
 297             {
 298               einfo ("%X%P: can not size stub section: %E\n");
 299               return;
 300             }
 301         }
 302     }
 303
 304   if (need_laying_out)
 305     hppaelf_layout_sections_again ();
 306
 307   if (! link_info.relocatable)
 308     {
 309       /* Set the global data pointer.  */
 310       if (! elf32_hppa_set_gp (output_bfd, &link_info))
 311         {
 312           einfo ("%X%P: can not set gp\n");
 313           return;
 314         }
 315
 316       /* Now build the linker stubs.  */
 317       if (stub_file->the_bfd->sections != NULL)
 318         {
 319           if (! elf32_hppa_build_stubs (&link_info))
 320             einfo ("%X%P: can not build stubs: %E\n");
 321         }
 322     }
 323 }
 324
 325
 326 /* Avoid processing the fake stub_file in vercheck, stat_needed and
 327    check_needed routines.  */
 328
 329 static void hppa_for_each_input_file_wrapper
 330   PARAMS ((lang_input_statement_type *));
 331 static void hppa_lang_for_each_input_file
 332   PARAMS ((void (*) (lang_input_statement_type *)));
 333
 334 static void (*real_func) PARAMS ((lang_input_statement_type *));
 335
 336 static void hppa_for_each_input_file_wrapper (l)
 337      lang_input_statement_type *l;
 338 {
 339   if (l != stub_file)
 340     (*real_func) (l);
 341 }
 342
 343 static void
 344 hppa_lang_for_each_input_file (func)
 345      void (*func) PARAMS ((lang_input_statement_type *));
 346 {
 347   real_func = func;
 348   lang_for_each_input_file (&hppa_for_each_input_file_wrapper);
 349 }
 350
 351 #define lang_for_each_input_file hppa_lang_for_each_input_file
 352
 353 EOF
 354
 355 # Define some shell vars to insert bits of code into the standard elf
 356 # parse_args and list_options functions.
 357 #
 358 PARSE_AND_LIST_PROLOGUE='
 359 #define OPTION_MULTI_SUBSPACE           301
 360 #define OPTION_STUBGROUP_SIZE           (OPTION_MULTI_SUBSPACE + 1)
 361 '
 362
 363 PARSE_AND_LIST_LONGOPTS='
 364   { "multi-subspace", no_argument, NULL, OPTION_MULTI_SUBSPACE },
 365   { "stub-group-size", required_argument, NULL, OPTION_STUBGROUP_SIZE },
 366 '
 367
 368 PARSE_AND_LIST_OPTIONS='
 369   fprintf (file, _("\
 370   --multi-subspace      Generate import and export stubs to support\n\
 371                           multiple sub-space shared libraries\n"
 372                    ));
 373   fprintf (file, _("\
 374   --stub-group-size=N   Maximum size of a group of input sections that can be\n\
 375                           handled by one stub section.  A negative value\n\
 376                           locates all stubs before their branches (with a\n\
 377                           group size of -N), while a positive value allows\n\
 378                           two groups of input sections, one before, and one\n\
 379                           after each stub section.  Values of +/-1 indicate\n\
 380                           the linker should choose suitable defaults.\n"
 381                    ));
 382 '
 383
 384 PARSE_AND_LIST_ARGS_CASES='
 385     case OPTION_MULTI_SUBSPACE:
 386       multi_subspace = 1;
 387       break;
 388
 389     case OPTION_STUBGROUP_SIZE:
 390       {
 391         const char *end;
 392         group_size = bfd_scan_vma (optarg, &end, 0);
 393         if (*end)
 394           einfo (_("%P%F: invalid number `%s'\''\n"), optarg);
 395       }
 396       break;
 397 '
 398
 399 # Put these extra hppaelf routines in ld_${EMULATION_NAME}_emulation
 400 #
 401 LDEMUL_AFTER_PARSE=hppaelf_after_parse
 402 LDEMUL_FINISH=gld${EMULATION_NAME}_finish
 403 LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS=hppaelf_create_output_section_statements