(wild_doit): Rename to lang_add_section.
[external/binutils.git] / 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   lang_add_section (&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