ld/emultempl/hppaelf.em

   1 # This shell script emits a C file. -*- C -*-
   2 #   Copyright 1991, 1993, 1994, 1997, 1999, 2000, 2001
   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 void hppaelf_delete_padding_statements
  33   PARAMS ((lang_statement_list_type *));
  34 static asection *hppaelf_add_stub_section
  35   PARAMS ((const char *, asection *));
  36 static void hppaelf_layaout_sections_again PARAMS ((void));
  37 static void hppaelf_finish PARAMS ((void));
  38
  39
  40 /* Fake input file for stubs.  */
  41 static lang_input_statement_type *stub_file;
  42
  43 /* Type of import/export stubs to build.  For a single sub-space model,
  44    we can build smaller import stubs and there is no need for export
  45    stubs.  */
  46 static int multi_subspace = 0;
  47
  48 /* Maximum size of a group of input sections that can be handled by
  49    one stub section.  A value of +/-1 indicates the bfd back-end
  50    should use a suitable default size.  */
  51 static bfd_signed_vma group_size = 1;
  52
  53 /* Stops the linker merging .text sections on a relocatable link,
  54    and adds millicode library to the list of input files.  */
  55
  56 static void
  57 hppaelf_after_parse ()
  58 {
  59   if (link_info.relocateable)
  60     lang_add_unique (".text");
  61 #if 0 /* enable this once we split millicode stuff from libgcc */
  62   else
  63     lang_add_input_file ("milli",
  64                          lang_input_file_is_l_enum,
  65                          NULL);
  66 #endif
  67 }
  68
  69 /* This is called before the input files are opened.  We create a new
  70    fake input file to hold the stub sections.  */
  71
  72 static void
  73 hppaelf_create_output_section_statements ()
  74 {
  75   stub_file = lang_add_input_file ("linker stubs",
  76                                    lang_input_file_is_fake_enum,
  77                                    NULL);
  78   stub_file->the_bfd = bfd_create ("linker stubs", output_bfd);
  79   if (stub_file->the_bfd == NULL
  80       || ! bfd_set_arch_mach (stub_file->the_bfd,
  81                               bfd_get_arch (output_bfd),
  82                               bfd_get_mach (output_bfd)))
  83     {
  84       einfo ("%X%P: can not create BFD %E\n");
  85       return;
  86     }
  87
  88   ldlang_add_file (stub_file);
  89 }
  90
  91 /* Walk all the lang statements splicing out any padding statements from
  92    the list.  */
  93
  94 static void
  95 hppaelf_delete_padding_statements (list)
  96      lang_statement_list_type *list;
  97 {
  98   lang_statement_union_type *s;
  99   lang_statement_union_type **ps;
 100   for (ps = &list->head; (s = *ps) != NULL; ps = &s->next)
 101     {
 102       switch (s->header.type)
 103         {
 104
 105         /* We want to recursively walk these sections.  */
 106         case lang_constructors_statement_enum:
 107           hppaelf_delete_padding_statements (&constructor_list);
 108           break;
 109
 110         case lang_output_section_statement_enum:
 111           hppaelf_delete_padding_statements (&s->output_section_statement.children);
 112           break;
 113
 114         case lang_group_statement_enum:
 115           hppaelf_delete_padding_statements (&s->group_statement.children);
 116           break;
 117
 118         case lang_wild_statement_enum:
 119           hppaelf_delete_padding_statements (&s->wild_statement.children);
 120           break;
 121
 122         /* Here's what we are really looking for.  Splice these out of
 123            the list.  */
 124         case lang_padding_statement_enum:
 125           *ps = s->next;
 126           if (*ps == NULL)
 127             list->tail = ps;
 128           break;
 129
 130         /* We don't care about these cases.  */
 131         case lang_data_statement_enum:
 132         case lang_object_symbols_statement_enum:
 133         case lang_output_statement_enum:
 134         case lang_target_statement_enum:
 135         case lang_input_section_enum:
 136         case lang_input_statement_enum:
 137         case lang_assignment_statement_enum:
 138         case lang_address_statement_enum:
 139           break;
 140
 141         default:
 142           abort ();
 143           break;
 144         }
 145     }
 146 }
 147
 148
 149 struct hook_stub_info
 150 {
 151   lang_statement_list_type add;
 152   asection *input_section;
 153 };
 154
 155 /* Traverse the linker tree to find the spot where the stub goes.  */
 156
 157 static boolean hook_in_stub
 158   PARAMS ((struct hook_stub_info *, lang_statement_union_type **));
 159
 160 static boolean
 161 hook_in_stub (info, lp)
 162      struct hook_stub_info *info;
 163      lang_statement_union_type **lp;
 164 {
 165   lang_statement_union_type *l;
 166   boolean ret;
 167
 168   for (; (l = *lp) != NULL; lp = &l->next)
 169     {
 170       switch (l->header.type)
 171         {
 172         case lang_constructors_statement_enum:
 173           ret = hook_in_stub (info, &constructor_list.head);
 174           if (ret)
 175             return ret;
 176           break;
 177
 178         case lang_output_section_statement_enum:
 179           ret = hook_in_stub (info,
 180                               &l->output_section_statement.children.head);
 181           if (ret)
 182             return ret;
 183           break;
 184
 185         case lang_wild_statement_enum:
 186           ret = hook_in_stub (info, &l->wild_statement.children.head);
 187           if (ret)
 188             return ret;
 189           break;
 190
 191         case lang_group_statement_enum:
 192           ret = hook_in_stub (info, &l->group_statement.children.head);
 193           if (ret)
 194             return ret;
 195           break;
 196
 197         case lang_input_section_enum:
 198           if (l->input_section.section == info->input_section)
 199             {
 200               /* We've found our section.  Insert the stub immediately
 201                  before its associated input section.  */
 202               *lp = info->add.head;
 203               *(info->add.tail) = l;
 204               return true;
 205             }
 206           break;
 207
 208         case lang_data_statement_enum:
 209         case lang_reloc_statement_enum:
 210         case lang_object_symbols_statement_enum:
 211         case lang_output_statement_enum:
 212         case lang_target_statement_enum:
 213         case lang_input_statement_enum:
 214         case lang_assignment_statement_enum:
 215         case lang_padding_statement_enum:
 216         case lang_address_statement_enum:
 217         case lang_fill_statement_enum:
 218           break;
 219
 220         default:
 221           FAIL ();
 222           break;
 223         }
 224     }
 225   return false;
 226 }
 227
 228
 229 /* Call-back for elf32_hppa_size_stubs.  */
 230
 231 /* Create a new stub section, and arrange for it to be linked
 232    immediately before INPUT_SECTION.  */
 233
 234 static asection *
 235 hppaelf_add_stub_section (stub_sec_name, input_section)
 236      const char *stub_sec_name;
 237      asection *input_section;
 238 {
 239   asection *stub_sec;
 240   flagword flags;
 241   asection *output_section;
 242   const char *secname;
 243   lang_output_section_statement_type *os;
 244   struct hook_stub_info info;
 245
 246   stub_sec = bfd_make_section_anyway (stub_file->the_bfd, stub_sec_name);
 247   if (stub_sec == NULL)
 248     goto err_ret;
 249
 250   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE
 251            | SEC_HAS_CONTENTS | SEC_RELOC | SEC_IN_MEMORY | SEC_KEEP);
 252   if (!bfd_set_section_flags (stub_file->the_bfd, stub_sec, flags))
 253     goto err_ret;
 254
 255   output_section = input_section->output_section;
 256   secname = bfd_get_section_name (output_section->owner, output_section);
 257   os = lang_output_section_find (secname);
 258
 259   info.input_section = input_section;
 260   lang_list_init (&info.add);
 261   wild_doit (&info.add, stub_sec, os, stub_file);
 262
 263   if (info.add.head == NULL)
 264     goto err_ret;
 265
 266   if (hook_in_stub (&info, &os->children.head))
 267     return stub_sec;
 268
 269  err_ret:
 270   einfo ("%X%P: can not make stub section: %E\n");
 271   return NULL;
 272 }
 273
 274
 275 /* Another call-back for elf32_hppa_size_stubs.  */
 276
 277 static void
 278 hppaelf_layaout_sections_again ()
 279 {
 280   /* If we have changed sizes of the stub sections, then we need
 281      to recalculate all the section offsets.  This may mean we need to
 282      add even more stubs.  */
 283
 284   /* Delete all the padding statements, they're no longer valid.  */
 285   hppaelf_delete_padding_statements (stat_ptr);
 286
 287   /* Resize the sections.  */
 288   lang_size_sections (stat_ptr->head, abs_output_section,
 289                       &stat_ptr->head, 0, (bfd_vma) 0, false);
 290
 291   /* Redo special stuff.  */
 292   ldemul_after_allocation ();
 293
 294   /* Do the assignments again.  */
 295   lang_do_assignments (stat_ptr->head, abs_output_section,
 296                        (fill_type) 0, (bfd_vma) 0);
 297 }
 298
 299
 300 /* Final emulation specific call.  For the PA we use this opportunity
 301    to build linker stubs.  */
 302
 303 static void
 304 hppaelf_finish ()
 305 {
 306   /* If generating a relocatable output file, then we don't
 307      have to examine the relocs.  */
 308   if (link_info.relocateable)
 309     return;
 310
 311   /* Call into the BFD backend to do the real work.  */
 312   if (! elf32_hppa_size_stubs (output_bfd,
 313                                stub_file->the_bfd,
 314                                &link_info,
 315                                multi_subspace,
 316                                group_size,
 317                                &hppaelf_add_stub_section,
 318                                &hppaelf_layaout_sections_again))
 319     {
 320       einfo ("%X%P: can not size stub section: %E\n");
 321       return;
 322     }
 323
 324   /* Set the global data pointer.  */
 325   if (! elf32_hppa_set_gp (output_bfd, &link_info))
 326     {
 327       einfo ("%X%P: can not set gp\n");
 328       return;
 329     }
 330
 331   /* Now build the linker stubs.  */
 332   if (stub_file->the_bfd->sections != NULL)
 333     {
 334       if (! elf32_hppa_build_stubs (&link_info))
 335         einfo ("%X%P: can not build stubs: %E\n");
 336     }
 337 }
 338
 339
 340 /* Avoid processing the fake stub_file in vercheck, stat_needed and
 341    check_needed routines.  */
 342
 343 static void hppa_for_each_input_file_wrapper
 344   PARAMS ((lang_input_statement_type *));
 345 static void hppa_lang_for_each_input_file
 346   PARAMS ((void (*) (lang_input_statement_type *)));
 347
 348 static void (*real_func) PARAMS ((lang_input_statement_type *));
 349
 350 static void hppa_for_each_input_file_wrapper (l)
 351      lang_input_statement_type *l;
 352 {
 353   if (l != stub_file)
 354     (*real_func) (l);
 355 }
 356
 357 static void
 358 hppa_lang_for_each_input_file (func)
 359      void (*func) PARAMS ((lang_input_statement_type *));
 360 {
 361   real_func = func;
 362   lang_for_each_input_file (&hppa_for_each_input_file_wrapper);
 363 }
 364
 365 #define lang_for_each_input_file hppa_lang_for_each_input_file
 366
 367 EOF
 368
 369 # Define some shell vars to insert bits of code into the standard elf
 370 # parse_args and list_options functions.
 371 #
 372 PARSE_AND_LIST_PROLOGUE='
 373 #define OPTION_MULTI_SUBSPACE           301
 374 #define OPTION_STUBGROUP_SIZE           (OPTION_MULTI_SUBSPACE + 1)
 375 '
 376
 377 # The options are repeated below so that no abbreviations are allowed.
 378 # Otherwise -s matches stub-group-size
 379 PARSE_AND_LIST_LONGOPTS='
 380   { "multi-subspace", no_argument, NULL, OPTION_MULTI_SUBSPACE },
 381   { "multi-subspace", no_argument, NULL, OPTION_MULTI_SUBSPACE },
 382   { "stub-group-size", required_argument, NULL, OPTION_STUBGROUP_SIZE },
 383   { "stub-group-size", required_argument, NULL, OPTION_STUBGROUP_SIZE },
 384 '
 385
 386 PARSE_AND_LIST_OPTIONS='
 387   fprintf (file, _("\
 388   --multi-subspace    Generate import and export stubs to support\n\
 389                         multiple sub-space shared libraries\n"
 390                    ));
 391   fprintf (file, _("\
 392   --stub-group-size=N Maximum size of a group of input sections that can be\n\
 393                         handled by one stub section.  A negative value\n\
 394                         locates all stubs before their branches (with a\n\
 395                         group size of -N), while a positive value allows\n\
 396                         two groups of input sections, one before, and one\n\
 397                         after each stub section.  Values of +/-1 indicate\n\
 398                         the linker should choose suitable defaults."
 399                    ));
 400 '
 401
 402 PARSE_AND_LIST_ARGS_CASES='
 403     case OPTION_MULTI_SUBSPACE:
 404       multi_subspace = 1;
 405       break;
 406
 407     case OPTION_STUBGROUP_SIZE:
 408       {
 409         const char *end;
 410         group_size = bfd_scan_vma (optarg, &end, 0);
 411         if (*end)
 412           einfo (_("%P%F: invalid number `%s'\''\n"), optarg);
 413       }
 414       break;
 415 '
 416
 417 # Put these extra hppaelf routines in ld_${EMULATION_NAME}_emulation
 418 #
 419 LDEMUL_AFTER_PARSE=hppaelf_after_parse
 420 LDEMUL_FINISH=hppaelf_finish
 421 LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS=hppaelf_create_output_section_statements