ld/ldemul.c

   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 }