1 /* ldemul.c -- clearing house for ld emulation states
2 Copyright (C) 1991-2023 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 #include "ctf-api.h"
26
27 #include "ld.h"
28 #include "ldmisc.h"
29 #include "ldexp.h"
30 #include "ldlang.h"
31 #include "ldfile.h"
32 #include "ldemul.h"
33 #include "ldmain.h"
34 #include "ldemul-list.h"
35
36 static ld_emulation_xfer_type *ld_emulation;
37
38 void
39 ldemul_hll (char *name)
40 {
41 ld_emulation->hll (name);
42 }
43
44 void
45 ldemul_syslib (char *name)
46 {
47 ld_emulation->syslib (name);
48 }
49
50 void
51 ldemul_after_parse (void)
52 {
53 ld_emulation->after_parse ();
54 }
55
56 void
57 ldemul_before_parse (void)
58 {
59 ld_emulation->before_parse ();
60 }
61
62 void
63 ldemul_before_plugin_all_symbols_read (void)
64 {
65 if (ld_emulation->before_plugin_all_symbols_read)
66 ld_emulation->before_plugin_all_symbols_read ();
67 }
68
69 void
70 ldemul_after_open (void)
71 {
72 ld_emulation->after_open ();
73 }
74
75 void
76 ldemul_after_check_relocs (void)
77 {
78 ld_emulation->after_check_relocs ();
79 }
80
81 void
82 ldemul_before_place_orphans (void)
83 {
84 ld_emulation->before_place_orphans ();
85 }
86
87 void
88 ldemul_after_allocation (void)
89 {
90 ld_emulation->after_allocation ();
91 }
92
93 void
94 ldemul_before_allocation (void)
95 {
96 ld_emulation->before_allocation ();
97 }
98
99 void
100 ldemul_set_output_arch (void)
101 {
102 ld_emulation->set_output_arch ();
103 }
104
105 void
106 ldemul_finish (void)
107 {
108 ld_emulation->finish ();
109 }
110
111 void
112 ldemul_set_symbols (void)
113 {
114 if (ld_emulation->set_symbols)
115 ld_emulation->set_symbols ();
116 }
117
118 void
119 ldemul_create_output_section_statements (void)
120 {
121 if (ld_emulation->create_output_section_statements)
122 ld_emulation->create_output_section_statements ();
123 }
124
125 char *
126 ldemul_get_script (int *isfile)
127 {
128 return ld_emulation->get_script (isfile);
129 }
130
131 bool
132 ldemul_open_dynamic_archive (const char *arch, search_dirs_type *search,
133 lang_input_statement_type *entry)
134 {
135 if (ld_emulation->open_dynamic_archive)
136 return (*ld_emulation->open_dynamic_archive) (arch, search, entry);
137 return false;
138 }
139
140 lang_output_section_statement_type *
141 ldemul_place_orphan (asection *s, const char *name, int constraint)
142 {
143 if (ld_emulation->place_orphan)
144 return (*ld_emulation->place_orphan) (s, name, constraint);
145 return NULL;
146 }
147
148 void
149 ldemul_add_options (int ns, char **shortopts, int nl,
150 struct option **longopts, int nrl,
151 struct option **really_longopts)
152 {
153 if (ld_emulation->add_options)
154 (*ld_emulation->add_options) (ns, shortopts, nl, longopts,
155 nrl, really_longopts);
156 }
157
158 bool
159 ldemul_handle_option (int optc)
160 {
161 if (ld_emulation->handle_option)
162 return (*ld_emulation->handle_option) (optc);
163 return false;
164 }
165
166 bool
167 ldemul_parse_args (int argc, char **argv)
168 {
169 /* Try and use the emulation parser if there is one. */
170 if (ld_emulation->parse_args)
171 return (*ld_emulation->parse_args) (argc, argv);
172 return false;
173 }
174
175 /* Let the emulation code handle an unrecognized file. */
176
177 bool
178 ldemul_unrecognized_file (lang_input_statement_type *entry)
179 {
180 if (ld_emulation->unrecognized_file)
181 return (*ld_emulation->unrecognized_file) (entry);
182 return false;
183 }
184
185 /* Let the emulation code handle a recognized file. */
186
187 bool
188 ldemul_recognized_file (lang_input_statement_type *entry)
189 {
190 if (ld_emulation->recognized_file)
191 return (*ld_emulation->recognized_file) (entry);
192 return false;
193 }
194
195 char *
196 ldemul_choose_target (int argc, char **argv)
197 {
198 return ld_emulation->choose_target (argc, argv);
199 }
200
201
202 /* The default choose_target function. */
203
204 char *
205 ldemul_default_target (int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED)
206 {
207 char *from_outside = getenv (TARGET_ENVIRON);
208 if (from_outside != (char *) NULL)
209 return from_outside;
210 return ld_emulation->target_name;
211 }
212
213 /* If the entry point was not specified as an address, then add the
214 symbol as undefined. This will cause ld to extract an archive
215 element defining the entry if ld is linking against such an archive.
216
217 We don't do this when generating shared libraries unless given -e
218 on the command line, because most shared libs are not designed to
219 be run as an executable. However, some are, eg. glibc ld.so and
220 may rely on the default linker script supplying ENTRY. So we can't
221 remove the ENTRY from the script, but would rather not insert
222 undefined _start syms. */
223
224 void
225 after_parse_default (void)
226 {
227 if (entry_symbol.name != NULL
228 && (bfd_link_executable (&link_info) || entry_from_cmdline))
229 {
230 bool is_vma = false;
231
232 if (entry_from_cmdline)
233 {
234 const char *send;
235
236 bfd_scan_vma (entry_symbol.name, &send, 0);
237 is_vma = *send == '\0';
238 }
239 if (!is_vma)
240 ldlang_add_undef (entry_symbol.name, entry_from_cmdline);
241 }
242 if (link_info.maxpagesize == 0)
243 link_info.maxpagesize = bfd_emul_get_maxpagesize (default_target);
244 if (link_info.commonpagesize == 0)
245 link_info.commonpagesize = bfd_emul_get_commonpagesize (default_target);
246 }
247
248 void
249 after_open_default (void)
250 {
251 link_info.big_endian = true;
252
253 if (bfd_big_endian (link_info.output_bfd))
254 ;
255 else if (bfd_little_endian (link_info.output_bfd))
256 link_info.big_endian = false;
257 else
258 {
259 if (command_line.endian == ENDIAN_BIG)
260 ;
261 else if (command_line.endian == ENDIAN_LITTLE)
262 link_info.big_endian = false;
263 else if (command_line.endian == ENDIAN_UNSET)
264 {
265 LANG_FOR_EACH_INPUT_STATEMENT (s)
266 if (s->the_bfd != NULL)
267 {
268 if (bfd_little_endian (s->the_bfd))
269 link_info.big_endian = false;
270 break;
271 }
272 }
273 }
274 }
275
276 void
277 after_check_relocs_default (void)
278 {
279 }
280
281 void
282 before_place_orphans_default (void)
283 {
284 }
285
286 void
287 after_allocation_default (void)
288 {
289 lang_relax_sections (false);
290 }
291
292 void
293 before_allocation_default (void)
294 {
295 if (!bfd_link_relocatable (&link_info))
296 strip_excluded_output_sections ();
297 }
298
299 void
300 finish_default (void)
301 {
302 if (!bfd_link_relocatable (&link_info))
303 _bfd_fix_excluded_sec_syms (link_info.output_bfd, &link_info);
304 }
305
306 void
307 set_output_arch_default (void)
308 {
309 /* Set the output architecture and machine if possible. */
310 bfd_set_arch_mach (link_info.output_bfd,
311 ldfile_output_architecture, ldfile_output_machine);
312 }
313
314 void
315 syslib_default (char *ignore ATTRIBUTE_UNUSED)
316 {
317 info_msg (_("%pS SYSLIB ignored\n"), NULL);
318 }
319
320 void
321 hll_default (char *ignore ATTRIBUTE_UNUSED)
322 {
323 info_msg (_("%pS HLL ignored\n"), NULL);
324 }
325
326 ld_emulation_xfer_type *ld_emulations[] = { EMULATION_LIST };
327
328 void
329 ldemul_choose_mode (char *target)
330 {
331 ld_emulation_xfer_type **eptr = ld_emulations;
332 /* Ignore "gld" prefix. */
333 if (target[0] == 'g' && target[1] == 'l' && target[2] == 'd')
334 target += 3;
335 for (; *eptr; eptr++)
336 {
337 if (strcmp (target, (*eptr)->emulation_name) == 0)
338 {
339 ld_emulation = *eptr;
340 return;
341 }
342 }
343 einfo (_("%P: unrecognised emulation mode: %s\n"), target);
344 einfo (_("Supported emulations: "));
345 ldemul_list_emulations (stderr);
346 einfo ("%F\n");
347 }
348
349 void
350 ldemul_list_emulations (FILE *f)
351 {
352 ld_emulation_xfer_type **eptr = ld_emulations;
353 bool first = true;
354
355 for (; *eptr; eptr++)
356 {
357 if (first)
358 first = false;
359 else
360 fprintf (f, " ");
361 fprintf (f, "%s", (*eptr)->emulation_name);
362 }
363 }
364
365 void
366 ldemul_list_emulation_options (FILE *f)
367 {
368 ld_emulation_xfer_type **eptr;
369 int options_found = 0;
370
371 for (eptr = ld_emulations; *eptr; eptr++)
372 {
373 ld_emulation_xfer_type *emul = *eptr;
374
375 if (emul->list_options)
376 {
377 fprintf (f, "%s: \n", emul->emulation_name);
378
379 emul->list_options (f);
380
381 options_found = 1;
382 }
383 }
384
385 if (!options_found)
386 fprintf (f, _(" no emulation specific options.\n"));
387 }
388
389 int
390 ldemul_find_potential_libraries (char *name, lang_input_statement_type *entry)
391 {
392 if (ld_emulation->find_potential_libraries)
393 return ld_emulation->find_potential_libraries (name, entry);
394
395 return 0;
396 }
397
398 struct bfd_elf_version_expr *
399 ldemul_new_vers_pattern (struct bfd_elf_version_expr *entry)
400 {
401 if (ld_emulation->new_vers_pattern)
402 entry = (*ld_emulation->new_vers_pattern) (entry);
403 return entry;
404 }
405
406 void
407 ldemul_extra_map_file_text (bfd *abfd, struct bfd_link_info *info, FILE *mapf)
408 {
409 if (ld_emulation->extra_map_file_text)
410 ld_emulation->extra_map_file_text (abfd, info, mapf);
411 }
412
413 int
414 ldemul_emit_ctf_early (void)
415 {
416 if (ld_emulation->emit_ctf_early)
417 return ld_emulation->emit_ctf_early ();
418 /* If the emulation doesn't know if it wants to emit CTF early, it is going
419 to do so. */
420 return 1;
421 }
422
423 void
424 ldemul_acquire_strings_for_ctf (struct ctf_dict *ctf_output,
425 struct elf_strtab_hash *symstrtab)
426 {
427 if (ld_emulation->acquire_strings_for_ctf)
428 ld_emulation->acquire_strings_for_ctf (ctf_output, symstrtab);
429 }
430
431 void
432 ldemul_new_dynsym_for_ctf (struct ctf_dict *ctf_output, int symidx,
433 struct elf_internal_sym *sym)
434 {
435 if (ld_emulation->new_dynsym_for_ctf)
436 ld_emulation->new_dynsym_for_ctf (ctf_output, symidx, sym);
437 }
438
439 bool
440 ldemul_print_symbol (struct bfd_link_hash_entry *hash_entry, void *ptr)
441 {
442 if (ld_emulation->print_symbol)
443 return ld_emulation->print_symbol (hash_entry, ptr);
444 return print_one_symbol (hash_entry, ptr);
445 }