Formatting fixes.
[external/binutils.git] / ld / ldemul.c
1 /* ldemul.c -- clearing house for ld emulation states
2    Copyright (C) 1991-2016 Free Software Foundation, Inc.
3
4    This file is part of the GNU Binutils.
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 3 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., 51 Franklin Street - Fifth Floor, Boston,
19    MA 02110-1301, USA.  */
20
21 #include "sysdep.h"
22 #include "bfd.h"
23 #include "getopt.h"
24 #include "bfdlink.h"
25
26 #include "ld.h"
27 #include "ldmisc.h"
28 #include "ldexp.h"
29 #include "ldlang.h"
30 #include "ldfile.h"
31 #include "ldemul.h"
32 #include "ldmain.h"
33 #include "ldemul-list.h"
34
35 static ld_emulation_xfer_type *ld_emulation;
36
37 void
38 ldemul_hll (char *name)
39 {
40   ld_emulation->hll (name);
41 }
42
43 void
44 ldemul_syslib (char *name)
45 {
46   ld_emulation->syslib (name);
47 }
48
49 void
50 ldemul_after_parse (void)
51 {
52   ld_emulation->after_parse ();
53 }
54
55 void
56 ldemul_before_parse (void)
57 {
58   ld_emulation->before_parse ();
59 }
60
61 void
62 ldemul_after_open (void)
63 {
64   ld_emulation->after_open ();
65 }
66
67 void
68 ldemul_after_allocation (void)
69 {
70   ld_emulation->after_allocation ();
71 }
72
73 void
74 ldemul_before_allocation (void)
75 {
76   ld_emulation->before_allocation ();
77 }
78
79 void
80 ldemul_set_output_arch (void)
81 {
82   ld_emulation->set_output_arch ();
83 }
84
85 void
86 ldemul_finish (void)
87 {
88   ld_emulation->finish ();
89 }
90
91 void
92 ldemul_set_symbols (void)
93 {
94   if (ld_emulation->set_symbols)
95     ld_emulation->set_symbols ();
96 }
97
98 void
99 ldemul_create_output_section_statements (void)
100 {
101   if (ld_emulation->create_output_section_statements)
102     ld_emulation->create_output_section_statements ();
103 }
104
105 char *
106 ldemul_get_script (int *isfile)
107 {
108   return ld_emulation->get_script (isfile);
109 }
110
111 bfd_boolean
112 ldemul_open_dynamic_archive (const char *arch, search_dirs_type *search,
113                              lang_input_statement_type *entry)
114 {
115   if (ld_emulation->open_dynamic_archive)
116     return (*ld_emulation->open_dynamic_archive) (arch, search, entry);
117   return FALSE;
118 }
119
120 lang_output_section_statement_type *
121 ldemul_place_orphan (asection *s, const char *name, int constraint)
122 {
123   if (ld_emulation->place_orphan)
124     return (*ld_emulation->place_orphan) (s, name, constraint);
125   return NULL;
126 }
127
128 void
129 ldemul_add_options (int ns, char **shortopts, int nl,
130                     struct option **longopts, int nrl,
131                     struct option **really_longopts)
132 {
133   if (ld_emulation->add_options)
134     (*ld_emulation->add_options) (ns, shortopts, nl, longopts,
135                                   nrl, really_longopts);
136 }
137
138 bfd_boolean
139 ldemul_handle_option (int optc)
140 {
141   if (ld_emulation->handle_option)
142     return (*ld_emulation->handle_option) (optc);
143   return FALSE;
144 }
145
146 bfd_boolean
147 ldemul_parse_args (int argc, char **argv)
148 {
149   /* Try and use the emulation parser if there is one.  */
150   if (ld_emulation->parse_args)
151     return (*ld_emulation->parse_args) (argc, argv);
152   return FALSE;
153 }
154
155 /* Let the emulation code handle an unrecognized file.  */
156
157 bfd_boolean
158 ldemul_unrecognized_file (lang_input_statement_type *entry)
159 {
160   if (ld_emulation->unrecognized_file)
161     return (*ld_emulation->unrecognized_file) (entry);
162   return FALSE;
163 }
164
165 /* Let the emulation code handle a recognized file.  */
166
167 bfd_boolean
168 ldemul_recognized_file (lang_input_statement_type *entry)
169 {
170   if (ld_emulation->recognized_file)
171     return (*ld_emulation->recognized_file) (entry);
172   return FALSE;
173 }
174
175 char *
176 ldemul_choose_target (int argc, char **argv)
177 {
178   return ld_emulation->choose_target (argc, argv);
179 }
180
181
182 /* The default choose_target function.  */
183
184 char *
185 ldemul_default_target (int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED)
186 {
187   char *from_outside = getenv (TARGET_ENVIRON);
188   if (from_outside != (char *) NULL)
189     return from_outside;
190   return ld_emulation->target_name;
191 }
192
193 /* If the entry point was not specified as an address, then add the
194    symbol as undefined.  This will cause ld to extract an archive
195    element defining the entry if ld is linking against such an archive.
196
197    We don't do this when generating shared libraries unless given -e
198    on the command line, because most shared libs are not designed to
199    be run as an executable.  However, some are, eg. glibc ld.so and
200    may rely on the default linker script supplying ENTRY.  So we can't
201    remove the ENTRY from the script, but would rather not insert
202    undefined _start syms.  */
203
204 void
205 after_parse_default (void)
206 {
207   if (entry_symbol.name != NULL
208       && (bfd_link_executable (&link_info) || entry_from_cmdline))
209     {
210       bfd_boolean is_vma = FALSE;
211
212       if (entry_from_cmdline)
213         {
214           const char *send;
215
216           bfd_scan_vma (entry_symbol.name, &send, 0);
217           is_vma = *send == '\0';
218         }
219       if (!is_vma)
220         ldlang_add_undef (entry_symbol.name, entry_from_cmdline);
221     }
222 }
223
224 void
225 after_open_default (void)
226 {
227 }
228
229 void
230 after_allocation_default (void)
231 {
232   lang_relax_sections (FALSE);
233 }
234
235 void
236 before_allocation_default (void)
237 {
238   if (!bfd_link_relocatable (&link_info))
239     strip_excluded_output_sections ();
240 }
241
242 void
243 finish_default (void)
244 {
245   if (!bfd_link_relocatable (&link_info))
246     _bfd_fix_excluded_sec_syms (link_info.output_bfd, &link_info);
247 }
248
249 void
250 set_output_arch_default (void)
251 {
252   /* Set the output architecture and machine if possible.  */
253   bfd_set_arch_mach (link_info.output_bfd,
254                      ldfile_output_architecture, ldfile_output_machine);
255
256   bfd_emul_set_maxpagesize (output_target, config.maxpagesize);
257   bfd_emul_set_commonpagesize (output_target, config.commonpagesize);
258 }
259
260 void
261 syslib_default (char *ignore ATTRIBUTE_UNUSED)
262 {
263   info_msg (_("%S SYSLIB ignored\n"), NULL);
264 }
265
266 void
267 hll_default (char *ignore ATTRIBUTE_UNUSED)
268 {
269   info_msg (_("%S HLL ignored\n"), NULL);
270 }
271
272 ld_emulation_xfer_type *ld_emulations[] = { EMULATION_LIST };
273
274 void
275 ldemul_choose_mode (char *target)
276 {
277   ld_emulation_xfer_type **eptr = ld_emulations;
278   /* Ignore "gld" prefix.  */
279   if (target[0] == 'g' && target[1] == 'l' && target[2] == 'd')
280     target += 3;
281   for (; *eptr; eptr++)
282     {
283       if (strcmp (target, (*eptr)->emulation_name) == 0)
284         {
285           ld_emulation = *eptr;
286           return;
287         }
288     }
289   einfo (_("%P: unrecognised emulation mode: %s\n"), target);
290   einfo (_("Supported emulations: "));
291   ldemul_list_emulations (stderr);
292   einfo ("%F\n");
293 }
294
295 void
296 ldemul_list_emulations (FILE *f)
297 {
298   ld_emulation_xfer_type **eptr = ld_emulations;
299   bfd_boolean first = TRUE;
300
301   for (; *eptr; eptr++)
302     {
303       if (first)
304         first = FALSE;
305       else
306         fprintf (f, " ");
307       fprintf (f, "%s", (*eptr)->emulation_name);
308     }
309 }
310
311 void
312 ldemul_list_emulation_options (FILE *f)
313 {
314   ld_emulation_xfer_type **eptr;
315   int options_found = 0;
316
317   for (eptr = ld_emulations; *eptr; eptr++)
318     {
319       ld_emulation_xfer_type *emul = *eptr;
320
321       if (emul->list_options)
322         {
323           fprintf (f, "%s: \n", emul->emulation_name);
324
325           emul->list_options (f);
326
327           options_found = 1;
328         }
329     }
330
331   if (!options_found)
332     fprintf (f, _("  no emulation specific options.\n"));
333 }
334
335 int
336 ldemul_find_potential_libraries (char *name, lang_input_statement_type *entry)
337 {
338   if (ld_emulation->find_potential_libraries)
339     return ld_emulation->find_potential_libraries (name, entry);
340
341   return 0;
342 }
343
344 struct bfd_elf_version_expr *
345 ldemul_new_vers_pattern (struct bfd_elf_version_expr *entry)
346 {
347   if (ld_emulation->new_vers_pattern)
348     entry = (*ld_emulation->new_vers_pattern) (entry);
349   return entry;
350 }
351
352 void
353 ldemul_extra_map_file_text (bfd *abfd, struct bfd_link_info *info, FILE *mapf)
354 {
355   if (ld_emulation->extra_map_file_text)
356     ld_emulation->extra_map_file_text (abfd, info, mapf);
357 }