1/* ldemul.c -- clearing house for ld emulation states 2 Copyright (C) 1991-2022 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 36static ld_emulation_xfer_type *ld_emulation; 37 38void 39ldemul_hll (char *name) 40{ 41 ld_emulation->hll (name); 42} 43 44void 45ldemul_syslib (char *name) 46{ 47 ld_emulation->syslib (name); 48} 49 50void 51ldemul_after_parse (void) 52{ 53 ld_emulation->after_parse (); 54} 55 56void 57ldemul_before_parse (void) 58{ 59 ld_emulation->before_parse (); 60} 61 62void 63ldemul_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 69void 70ldemul_after_open (void) 71{ 72 ld_emulation->after_open (); 73} 74 75void 76ldemul_after_check_relocs (void) 77{ 78 ld_emulation->after_check_relocs (); 79} 80 81void 82ldemul_before_place_orphans (void) 83{ 84 ld_emulation->before_place_orphans (); 85} 86 87void 88ldemul_after_allocation (void) 89{ 90 ld_emulation->after_allocation (); 91} 92 93void 94ldemul_before_allocation (void) 95{ 96 ld_emulation->before_allocation (); 97} 98 99void 100ldemul_set_output_arch (void) 101{ 102 ld_emulation->set_output_arch (); 103} 104 105void 106ldemul_finish (void) 107{ 108 ld_emulation->finish (); 109} 110 111void 112ldemul_set_symbols (void) 113{ 114 if (ld_emulation->set_symbols) 115 ld_emulation->set_symbols (); 116} 117 118void 119ldemul_create_output_section_statements (void) 120{ 121 if (ld_emulation->create_output_section_statements) 122 ld_emulation->create_output_section_statements (); 123} 124 125char * 126ldemul_get_script (int *isfile) 127{ 128 return ld_emulation->get_script (isfile); 129} 130 131bool 132ldemul_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 140lang_output_section_statement_type * 141ldemul_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 148void 149ldemul_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 158bool 159ldemul_handle_option (int optc) 160{ 161 if (ld_emulation->handle_option) 162 return (*ld_emulation->handle_option) (optc); 163 return false; 164} 165 166bool 167ldemul_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 177bool 178ldemul_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 187bool 188ldemul_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 195char * 196ldemul_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 204char * 205ldemul_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 224void 225after_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 248void 249after_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 276void 277after_check_relocs_default (void) 278{ 279} 280 281void 282before_place_orphans_default (void) 283{ 284} 285 286void 287after_allocation_default (void) 288{ 289 lang_relax_sections (false); 290} 291 292void 293before_allocation_default (void) 294{ 295 if (!bfd_link_relocatable (&link_info)) 296 strip_excluded_output_sections (); 297} 298 299void 300finish_default (void) 301{ 302 if (!bfd_link_relocatable (&link_info)) 303 _bfd_fix_excluded_sec_syms (link_info.output_bfd, &link_info); 304} 305 306void 307set_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 314void 315syslib_default (char *ignore ATTRIBUTE_UNUSED) 316{ 317 info_msg (_("%pS SYSLIB ignored\n"), NULL); 318} 319 320void 321hll_default (char *ignore ATTRIBUTE_UNUSED) 322{ 323 info_msg (_("%pS HLL ignored\n"), NULL); 324} 325 326ld_emulation_xfer_type *ld_emulations[] = { EMULATION_LIST }; 327 328void 329ldemul_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 349void 350ldemul_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 365void 366ldemul_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 389int 390ldemul_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 398struct bfd_elf_version_expr * 399ldemul_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 406void 407ldemul_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 413int 414ldemul_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 423void 424ldemul_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 431void 432ldemul_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 439bool 440ldemul_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} 446