ld/ldemul.c

   1 /* ldemul.c -- clearing house for ld emulation states
   2    Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   3    2001, 2002, 2003, 2005, 2007, 2008, 2009
   4    Free Software Foundation, Inc.
   5
   6    This file is part of the GNU Binutils.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  21    MA 02110-1301, USA.  */
  22
  23 #include "sysdep.h"
  24 #include "bfd.h"
  25 #include "getopt.h"
  26 #include "bfdlink.h"
  27
  28 #include "ld.h"
  29 #include "ldmisc.h"
  30 #include "ldexp.h"
  31 #include "ldlang.h"
  32 #include "ldfile.h"
  33 #include "ldemul.h"
  34 #include "ldmain.h"
  35 #include "ldemul-list.h"
  36
  37 static ld_emulation_xfer_type *ld_emulation;
  38
  39 void
  40 ldemul_hll (char *name)
  41 {
  42   ld_emulation->hll (name);
  43 }
  44
  45 void
  46 ldemul_syslib (char *name)
  47 {
  48   ld_emulation->syslib (name);
  49 }
  50
  51 void
  52 ldemul_after_parse (void)
  53 {
  54   ld_emulation->after_parse ();
  55 }
  56
  57 void
  58 ldemul_before_parse (void)
  59 {
  60   ld_emulation->before_parse ();
  61 }
  62
  63 void
  64 ldemul_after_open (void)
  65 {
  66   ld_emulation->after_open ();
  67 }
  68
  69 void
  70 ldemul_after_allocation (void)
  71 {
  72   ld_emulation->after_allocation ();
  73 }
  74
  75 void
  76 ldemul_before_allocation (void)
  77 {
  78   ld_emulation->before_allocation ();
  79 }
  80
  81 void
  82 ldemul_set_output_arch (void)
  83 {
  84   ld_emulation->set_output_arch ();
  85 }
  86
  87 void
  88 ldemul_finish (void)
  89 {
  90   ld_emulation->finish ();
  91 }
  92
  93 void
  94 ldemul_set_symbols (void)
  95 {
  96   if (ld_emulation->set_symbols)
  97     ld_emulation->set_symbols ();
  98 }
  99
 100 void
 101 ldemul_create_output_section_statements (void)
 102 {
 103   if (ld_emulation->create_output_section_statements)
 104     ld_emulation->create_output_section_statements ();
 105 }
 106
 107 char *
 108 ldemul_get_script (int *isfile)
 109 {
 110   return ld_emulation->get_script (isfile);
 111 }
 112
 113 bfd_boolean
 114 ldemul_open_dynamic_archive (const char *arch, search_dirs_type *search,
 115                              lang_input_statement_type *entry)
 116 {
 117   if (ld_emulation->open_dynamic_archive)
 118     return (*ld_emulation->open_dynamic_archive) (arch, search, entry);
 119   return FALSE;
 120 }
 121
 122 lang_output_section_statement_type *
 123 ldemul_place_orphan (asection *s, const char *name, int constraint)
 124 {
 125   if (ld_emulation->place_orphan)
 126     return (*ld_emulation->place_orphan) (s, name, constraint);
 127   return NULL;
 128 }
 129
 130 void
 131 ldemul_add_options (int ns, char **shortopts, int nl,
 132                     struct option **longopts, int nrl,
 133                     struct option **really_longopts)
 134 {
 135   if (ld_emulation->add_options)
 136     (*ld_emulation->add_options) (ns, shortopts, nl, longopts,
 137                                   nrl, really_longopts);
 138 }
 139
 140 bfd_boolean
 141 ldemul_handle_option (int optc)
 142 {
 143   if (ld_emulation->handle_option)
 144     return (*ld_emulation->handle_option) (optc);
 145   return FALSE;
 146 }
 147
 148 bfd_boolean
 149 ldemul_parse_args (int argc, char **argv)
 150 {
 151   /* Try and use the emulation parser if there is one.  */
 152   if (ld_emulation->parse_args)
 153     return (*ld_emulation->parse_args) (argc, argv);
 154   return FALSE;
 155 }
 156
 157 /* Let the emulation code handle an unrecognized file.  */
 158
 159 bfd_boolean
 160 ldemul_unrecognized_file (lang_input_statement_type *entry)
 161 {
 162   if (ld_emulation->unrecognized_file)
 163     return (*ld_emulation->unrecognized_file) (entry);
 164   return FALSE;
 165 }
 166
 167 /* Let the emulation code handle a recognized file.  */
 168
 169 bfd_boolean
 170 ldemul_recognized_file (lang_input_statement_type *entry)
 171 {
 172   if (ld_emulation->recognized_file)
 173     return (*ld_emulation->recognized_file) (entry);
 174   return FALSE;
 175 }
 176
 177 char *
 178 ldemul_choose_target (int argc, char **argv)
 179 {
 180   return ld_emulation->choose_target (argc, argv);
 181 }
 182
 183
 184 /* The default choose_target function.  */
 185
 186 char *
 187 ldemul_default_target (int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED)
 188 {
 189   char *from_outside = getenv (TARGET_ENVIRON);
 190   if (from_outside != (char *) NULL)
 191     return from_outside;
 192   return ld_emulation->target_name;
 193 }
 194
 195 /* If the entry point was not specified as an address, then add the
 196    symbol as undefined.  This will cause ld to extract an archive
 197    element defining the entry if ld is linking against such an archive.
 198
 199    We don't do this when generating shared libraries unless given -e
 200    on the command line, because most shared libs are not designed to
 201    be run as an executable.  However, some are, eg. glibc ld.so and
 202    may rely on the default linker script supplying ENTRY.  So we can't
 203    remove the ENTRY from the script, but would rather not insert
 204    undefined _start syms.  */
 205
 206 void
 207 after_parse_default (void)
 208 {
 209   if (entry_symbol.name != NULL
 210       && (link_info.executable || entry_from_cmdline))
 211     {
 212       bfd_boolean is_vma = FALSE;
 213
 214       if (entry_from_cmdline)
 215         {
 216           const char *send;
 217
 218           bfd_scan_vma (entry_symbol.name, &send, 0);
 219           is_vma = *send == '\0';
 220         }
 221       if (!is_vma)
 222         ldlang_add_undef (entry_symbol.name, entry_from_cmdline);
 223     }
 224 }
 225
 226 void
 227 after_open_default (void)
 228 {
 229   struct bfd_link_hash_entry *h;
 230
 231   h = bfd_wrapped_link_hash_lookup (link_info.output_bfd,
 232                                     &link_info,
 233                                     "__ld_compatibility",
 234                                     FALSE, FALSE, TRUE);
 235   if (h != NULL
 236       && (h->type == bfd_link_hash_defined
 237           || h->type == bfd_link_hash_defweak))
 238     ld_compatibility = h->u.def.value;
 239 }
 240
 241 void
 242 after_allocation_default (void)
 243 {
 244   lang_relax_sections (FALSE);
 245 }
 246
 247 void
 248 before_allocation_default (void)
 249 {
 250   if (!link_info.relocatable)
 251     strip_excluded_output_sections ();
 252 }
 253
 254 void
 255 finish_default (void)
 256 {
 257   if (!link_info.relocatable)
 258     _bfd_fix_excluded_sec_syms (link_info.output_bfd, &link_info);
 259 }
 260
 261 void
 262 set_output_arch_default (void)
 263 {
 264   /* Set the output architecture and machine if possible.  */
 265   bfd_set_arch_mach (link_info.output_bfd,
 266                      ldfile_output_architecture, ldfile_output_machine);
 267
 268   bfd_emul_set_maxpagesize (output_target, config.maxpagesize);
 269   bfd_emul_set_commonpagesize (output_target, config.commonpagesize);
 270 }
 271
 272 void
 273 syslib_default (char *ignore ATTRIBUTE_UNUSED)
 274 {
 275   info_msg (_("%S SYSLIB ignored\n"));
 276 }
 277
 278 void
 279 hll_default (char *ignore ATTRIBUTE_UNUSED)
 280 {
 281   info_msg (_("%S HLL ignored\n"));
 282 }
 283
 284 ld_emulation_xfer_type *ld_emulations[] = { EMULATION_LIST };
 285
 286 void
 287 ldemul_choose_mode (char *target)
 288 {
 289   ld_emulation_xfer_type **eptr = ld_emulations;
 290   /* Ignore "gld" prefix.  */
 291   if (target[0] == 'g' && target[1] == 'l' && target[2] == 'd')
 292     target += 3;
 293   for (; *eptr; eptr++)
 294     {
 295       if (strcmp (target, (*eptr)->emulation_name) == 0)
 296         {
 297           ld_emulation = *eptr;
 298           return;
 299         }
 300     }
 301   einfo (_("%P: unrecognised emulation mode: %s\n"), target);
 302   einfo (_("Supported emulations: "));
 303   ldemul_list_emulations (stderr);
 304   einfo ("%F\n");
 305 }
 306
 307 void
 308 ldemul_list_emulations (FILE *f)
 309 {
 310   ld_emulation_xfer_type **eptr = ld_emulations;
 311   bfd_boolean first = TRUE;
 312
 313   for (; *eptr; eptr++)
 314     {
 315       if (first)
 316         first = FALSE;
 317       else
 318         fprintf (f, " ");
 319       fprintf (f, "%s", (*eptr)->emulation_name);
 320     }
 321 }
 322
 323 void
 324 ldemul_list_emulation_options (FILE *f)
 325 {
 326   ld_emulation_xfer_type **eptr;
 327   int options_found = 0;
 328
 329   for (eptr = ld_emulations; *eptr; eptr++)
 330     {
 331       ld_emulation_xfer_type *emul = *eptr;
 332
 333       if (emul->list_options)
 334         {
 335           fprintf (f, "%s: \n", emul->emulation_name);
 336
 337           emul->list_options (f);
 338
 339           options_found = 1;
 340         }
 341     }
 342
 343   if (! options_found)
 344     fprintf (f, _("  no emulation specific options.\n"));
 345 }
 346
 347 int
 348 ldemul_find_potential_libraries (char *name, lang_input_statement_type *entry)
 349 {
 350   if (ld_emulation->find_potential_libraries)
 351     return ld_emulation->find_potential_libraries (name, entry);
 352
 353   return 0;
 354 }
 355
 356 struct bfd_elf_version_expr *
 357 ldemul_new_vers_pattern (struct bfd_elf_version_expr *entry)
 358 {
 359   if (ld_emulation->new_vers_pattern)
 360     entry = (*ld_emulation->new_vers_pattern) (entry);
 361   return entry;
 362 }