ld/ldemul.c

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