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