ld/ldemul.c

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