ld/emultempl/pe.em

   1 # This shell script emits a C file. -*- C -*-
   2 # It does some substitutions.
   3 if [ -z "$MACHINE" ]; then
   4   OUTPUT_ARCH=${ARCH}
   5 else
   6   OUTPUT_ARCH=${ARCH}:${MACHINE}
   7 fi
   8 rm -f e${EMULATION_NAME}.c
   9 (echo;echo;echo;echo;echo)>e${EMULATION_NAME}.c # there, now line numbers match ;-)
  10 cat >>e${EMULATION_NAME}.c <<EOF
  11 /* This file is part of GLD, the Gnu Linker.
  12    Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
  13    2005 Free Software Foundation, Inc.
  14
  15    This program is free software; you can redistribute it and/or modify
  16    it under the terms of the GNU General Public License as published by
  17    the Free Software Foundation; either version 2 of the License, or
  18    (at your option) any later version.
  19
  20    This program is distributed in the hope that it will be useful,
  21    but WITHOUT ANY WARRANTY; without even the implied warranty of
  22    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23    GNU General Public License for more details.
  24
  25    You should have received a copy of the GNU General Public License
  26    along with this program; if not, write to the Free Software
  27    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  28
  29 /* For WINDOWS_NT */
  30 /* The original file generated returned different default scripts depending
  31    on whether certain switches were set, but these switches pertain to the
  32    Linux system and that particular version of coff.  In the NT case, we
  33    only determine if the subsystem is console or windows in order to select
  34    the correct entry point by default. */
  35
  36 #define TARGET_IS_${EMULATION_NAME}
  37
  38 /* Do this before including bfd.h, so we prototype the right functions.  */
  39 #ifdef TARGET_IS_arm_epoc_pe
  40 #define bfd_arm_pe_allocate_interworking_sections \
  41         bfd_arm_epoc_pe_allocate_interworking_sections
  42 #define bfd_arm_pe_get_bfd_for_interworking \
  43         bfd_arm_epoc_pe_get_bfd_for_interworking
  44 #define bfd_arm_pe_process_before_allocation \
  45         bfd_arm_epoc_pe_process_before_allocation
  46 #endif
  47
  48 #include "bfd.h"
  49 #include "sysdep.h"
  50 #include "bfdlink.h"
  51 #include "getopt.h"
  52 #include "libiberty.h"
  53 #include "ld.h"
  54 #include "ldmain.h"
  55 #include "ldexp.h"
  56 #include "ldlang.h"
  57 #include "ldfile.h"
  58 #include "ldemul.h"
  59 #include <ldgram.h>
  60 #include "ldlex.h"
  61 #include "ldmisc.h"
  62 #include "ldctor.h"
  63 #include "coff/internal.h"
  64
  65 /* FIXME: See bfd/peXXigen.c for why we include an architecture specific
  66    header in generic PE code.  */
  67 #include "coff/i386.h"
  68 #include "coff/pe.h"
  69
  70 /* FIXME: This is a BFD internal header file, and we should not be
  71    using it here.  */
  72 #include "../bfd/libcoff.h"
  73
  74 #include "deffile.h"
  75 #include "pe-dll.h"
  76 #include "safe-ctype.h"
  77
  78 /* Permit the emulation parameters to override the default section
  79    alignment by setting OVERRIDE_SECTION_ALIGNMENT.  FIXME: This makes
  80    it seem that include/coff/internal.h should not define
  81    PE_DEF_SECTION_ALIGNMENT.  */
  82 #if PE_DEF_SECTION_ALIGNMENT != ${OVERRIDE_SECTION_ALIGNMENT:-PE_DEF_SECTION_ALIGNMENT}
  83 #undef PE_DEF_SECTION_ALIGNMENT
  84 #define PE_DEF_SECTION_ALIGNMENT ${OVERRIDE_SECTION_ALIGNMENT}
  85 #endif
  86
  87 #if defined(TARGET_IS_i386pe)
  88 #define DLL_SUPPORT
  89 #endif
  90 #if defined(TARGET_IS_shpe) || defined(TARGET_IS_mipspe) || defined(TARGET_IS_armpe)
  91 #define DLL_SUPPORT
  92 #endif
  93
  94 #if defined(TARGET_IS_i386pe) || ! defined(DLL_SUPPORT)
  95 #define PE_DEF_SUBSYSTEM                3
  96 #else
  97 #undef NT_EXE_IMAGE_BASE
  98 #undef PE_DEF_SECTION_ALIGNMENT
  99 #undef PE_DEF_FILE_ALIGNMENT
 100 #define NT_EXE_IMAGE_BASE               0x00010000
 101 #ifdef TARGET_IS_armpe
 102 #define PE_DEF_SECTION_ALIGNMENT        0x00001000
 103 #define PE_DEF_SUBSYSTEM                9
 104 #else
 105 #define PE_DEF_SECTION_ALIGNMENT        0x00000400
 106 #define PE_DEF_SUBSYSTEM                2
 107 #endif
 108 #define PE_DEF_FILE_ALIGNMENT           0x00000200
 109 #endif
 110
 111
 112 static struct internal_extra_pe_aouthdr pe;
 113 static int dll;
 114 static flagword real_flags = 0;
 115 static int support_old_code = 0;
 116 static char * thumb_entry_symbol = NULL;
 117 static lang_assignment_statement_type *image_base_statement = 0;
 118
 119 #ifdef DLL_SUPPORT
 120 static int pe_enable_stdcall_fixup = -1; /* 0=disable 1=enable.  */
 121 static char *pe_out_def_filename = NULL;
 122 static char *pe_implib_filename = NULL;
 123 static int pe_enable_auto_image_base = 0;
 124 static char *pe_dll_search_prefix = NULL;
 125 #endif
 126
 127 extern const char *output_filename;
 128
 129 static void
 130 gld_${EMULATION_NAME}_before_parse (void)
 131 {
 132   ldfile_set_output_arch ("${OUTPUT_ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`);
 133   output_filename = "${EXECUTABLE_NAME:-a.exe}";
 134 #ifdef DLL_SUPPORT
 135   config.dynamic_link = TRUE;
 136   config.has_shared = 1;
 137   link_info.pei386_auto_import = -1;
 138   link_info.pei386_runtime_pseudo_reloc = FALSE;
 139
 140 #if (PE_DEF_SUBSYSTEM == 9) || (PE_DEF_SUBSYSTEM == 2)
 141 #if defined TARGET_IS_mipspe || defined TARGET_IS_armpe
 142   lang_add_entry ("WinMainCRTStartup", FALSE);
 143 #else
 144   lang_add_entry ("_WinMainCRTStartup", FALSE);
 145 #endif
 146 #endif
 147 #endif
 148 }
 149 \f
 150 /* PE format extra command line options.  */
 151
 152 /* Used for setting flags in the PE header.  */
 153 #define OPTION_BASE_FILE                (300  + 1)
 154 #define OPTION_DLL                      (OPTION_BASE_FILE + 1)
 155 #define OPTION_FILE_ALIGNMENT           (OPTION_DLL + 1)
 156 #define OPTION_IMAGE_BASE               (OPTION_FILE_ALIGNMENT + 1)
 157 #define OPTION_MAJOR_IMAGE_VERSION      (OPTION_IMAGE_BASE + 1)
 158 #define OPTION_MAJOR_OS_VERSION         (OPTION_MAJOR_IMAGE_VERSION + 1)
 159 #define OPTION_MAJOR_SUBSYSTEM_VERSION  (OPTION_MAJOR_OS_VERSION + 1)
 160 #define OPTION_MINOR_IMAGE_VERSION      (OPTION_MAJOR_SUBSYSTEM_VERSION + 1)
 161 #define OPTION_MINOR_OS_VERSION         (OPTION_MINOR_IMAGE_VERSION + 1)
 162 #define OPTION_MINOR_SUBSYSTEM_VERSION  (OPTION_MINOR_OS_VERSION + 1)
 163 #define OPTION_SECTION_ALIGNMENT        (OPTION_MINOR_SUBSYSTEM_VERSION + 1)
 164 #define OPTION_STACK                    (OPTION_SECTION_ALIGNMENT + 1)
 165 #define OPTION_SUBSYSTEM                (OPTION_STACK + 1)
 166 #define OPTION_HEAP                     (OPTION_SUBSYSTEM + 1)
 167 #define OPTION_SUPPORT_OLD_CODE         (OPTION_HEAP + 1)
 168 #define OPTION_OUT_DEF                  (OPTION_SUPPORT_OLD_CODE + 1)
 169 #define OPTION_EXPORT_ALL               (OPTION_OUT_DEF + 1)
 170 #define OPTION_EXCLUDE_SYMBOLS          (OPTION_EXPORT_ALL + 1)
 171 #define OPTION_KILL_ATS                 (OPTION_EXCLUDE_SYMBOLS + 1)
 172 #define OPTION_STDCALL_ALIASES          (OPTION_KILL_ATS + 1)
 173 #define OPTION_ENABLE_STDCALL_FIXUP     (OPTION_STDCALL_ALIASES + 1)
 174 #define OPTION_DISABLE_STDCALL_FIXUP    (OPTION_ENABLE_STDCALL_FIXUP + 1)
 175 #define OPTION_IMPLIB_FILENAME          (OPTION_DISABLE_STDCALL_FIXUP + 1)
 176 #define OPTION_THUMB_ENTRY              (OPTION_IMPLIB_FILENAME + 1)
 177 #define OPTION_WARN_DUPLICATE_EXPORTS   (OPTION_THUMB_ENTRY + 1)
 178 #define OPTION_IMP_COMPAT               (OPTION_WARN_DUPLICATE_EXPORTS + 1)
 179 #define OPTION_ENABLE_AUTO_IMAGE_BASE   (OPTION_IMP_COMPAT + 1)
 180 #define OPTION_DISABLE_AUTO_IMAGE_BASE  (OPTION_ENABLE_AUTO_IMAGE_BASE + 1)
 181 #define OPTION_DLL_SEARCH_PREFIX        (OPTION_DISABLE_AUTO_IMAGE_BASE + 1)
 182 #define OPTION_NO_DEFAULT_EXCLUDES      (OPTION_DLL_SEARCH_PREFIX + 1)
 183 #define OPTION_DLL_ENABLE_AUTO_IMPORT   (OPTION_NO_DEFAULT_EXCLUDES + 1)
 184 #define OPTION_DLL_DISABLE_AUTO_IMPORT  (OPTION_DLL_ENABLE_AUTO_IMPORT + 1)
 185 #define OPTION_ENABLE_EXTRA_PE_DEBUG    (OPTION_DLL_DISABLE_AUTO_IMPORT + 1)
 186 #define OPTION_EXCLUDE_LIBS             (OPTION_ENABLE_EXTRA_PE_DEBUG + 1)
 187 #define OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC  \
 188                                         (OPTION_EXCLUDE_LIBS + 1)
 189 #define OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC \
 190                                         (OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC + 1)
 191 #define OPTION_LARGE_ADDRESS_AWARE \
 192                                         (OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC + 1)
 193
 194 static void
 195 gld${EMULATION_NAME}_add_options
 196   (int ns ATTRIBUTE_UNUSED, char **shortopts ATTRIBUTE_UNUSED, int nl,
 197     struct option **longopts, int nrl ATTRIBUTE_UNUSED,
 198     struct option **really_longopts ATTRIBUTE_UNUSED)
 199 {
 200   static const struct option xtra_long[] = {
 201     /* PE options */
 202     {"base-file", required_argument, NULL, OPTION_BASE_FILE},
 203     {"dll", no_argument, NULL, OPTION_DLL},
 204     {"file-alignment", required_argument, NULL, OPTION_FILE_ALIGNMENT},
 205     {"heap", required_argument, NULL, OPTION_HEAP},
 206     {"image-base", required_argument, NULL, OPTION_IMAGE_BASE},
 207     {"major-image-version", required_argument, NULL, OPTION_MAJOR_IMAGE_VERSION},
 208     {"major-os-version", required_argument, NULL, OPTION_MAJOR_OS_VERSION},
 209     {"major-subsystem-version", required_argument, NULL, OPTION_MAJOR_SUBSYSTEM_VERSION},
 210     {"minor-image-version", required_argument, NULL, OPTION_MINOR_IMAGE_VERSION},
 211     {"minor-os-version", required_argument, NULL, OPTION_MINOR_OS_VERSION},
 212     {"minor-subsystem-version", required_argument, NULL, OPTION_MINOR_SUBSYSTEM_VERSION},
 213     {"section-alignment", required_argument, NULL, OPTION_SECTION_ALIGNMENT},
 214     {"stack", required_argument, NULL, OPTION_STACK},
 215     {"subsystem", required_argument, NULL, OPTION_SUBSYSTEM},
 216     {"support-old-code", no_argument, NULL, OPTION_SUPPORT_OLD_CODE},
 217     {"thumb-entry", required_argument, NULL, OPTION_THUMB_ENTRY},
 218 #ifdef DLL_SUPPORT
 219     /* getopt allows abbreviations, so we do this to stop it from treating -o
 220        as an abbreviation for this option */
 221     {"output-def", required_argument, NULL, OPTION_OUT_DEF},
 222     {"output-def", required_argument, NULL, OPTION_OUT_DEF},
 223     {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL},
 224     {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMBOLS},
 225     {"exclude-libs", required_argument, NULL, OPTION_EXCLUDE_LIBS},
 226     {"kill-at", no_argument, NULL, OPTION_KILL_ATS},
 227     {"add-stdcall-alias", no_argument, NULL, OPTION_STDCALL_ALIASES},
 228     {"enable-stdcall-fixup", no_argument, NULL, OPTION_ENABLE_STDCALL_FIXUP},
 229     {"disable-stdcall-fixup", no_argument, NULL, OPTION_DISABLE_STDCALL_FIXUP},
 230     {"out-implib", required_argument, NULL, OPTION_IMPLIB_FILENAME},
 231     {"warn-duplicate-exports", no_argument, NULL, OPTION_WARN_DUPLICATE_EXPORTS},
 232     /* getopt() allows abbreviations, so we do this to stop it from
 233        treating -c as an abbreviation for these --compat-implib.  */
 234     {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT},
 235     {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT},
 236     {"enable-auto-image-base", no_argument, NULL, OPTION_ENABLE_AUTO_IMAGE_BASE},
 237     {"disable-auto-image-base", no_argument, NULL, OPTION_DISABLE_AUTO_IMAGE_BASE},
 238     {"dll-search-prefix", required_argument, NULL, OPTION_DLL_SEARCH_PREFIX},
 239     {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES},
 240     {"enable-auto-import", no_argument, NULL, OPTION_DLL_ENABLE_AUTO_IMPORT},
 241     {"disable-auto-import", no_argument, NULL, OPTION_DLL_DISABLE_AUTO_IMPORT},
 242     {"enable-extra-pe-debug", no_argument, NULL, OPTION_ENABLE_EXTRA_PE_DEBUG},
 243     {"enable-runtime-pseudo-reloc", no_argument, NULL, OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC},
 244     {"disable-runtime-pseudo-reloc", no_argument, NULL, OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC},
 245 #endif
 246     {"large-address-aware", no_argument, NULL, OPTION_LARGE_ADDRESS_AWARE},
 247     {NULL, no_argument, NULL, 0}
 248   };
 249
 250   *longopts = (struct option *)
 251     xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long));
 252   memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long));
 253 }
 254
 255 /* PE/WIN32; added routines to get the subsystem type, heap and/or stack
 256    parameters which may be input from the command line.  */
 257
 258 typedef struct
 259 {
 260   void *ptr;
 261   int size;
 262   int value;
 263   char *symbol;
 264   int inited;
 265 } definfo;
 266
 267 #define D(field,symbol,def)  {&pe.field,sizeof(pe.field), def, symbol,0}
 268
 269 static definfo init[] =
 270 {
 271   /* imagebase must be first */
 272 #define IMAGEBASEOFF 0
 273   D(ImageBase,"__image_base__", NT_EXE_IMAGE_BASE),
 274 #define DLLOFF 1
 275   {&dll, sizeof(dll), 0, "__dll__", 0},
 276   D(SectionAlignment,"__section_alignment__", PE_DEF_SECTION_ALIGNMENT),
 277   D(FileAlignment,"__file_alignment__", PE_DEF_FILE_ALIGNMENT),
 278   D(MajorOperatingSystemVersion,"__major_os_version__", 4),
 279   D(MinorOperatingSystemVersion,"__minor_os_version__", 0),
 280   D(MajorImageVersion,"__major_image_version__", 1),
 281   D(MinorImageVersion,"__minor_image_version__", 0),
 282 #ifdef TARGET_IS_armpe
 283   D(MajorSubsystemVersion,"__major_subsystem_version__", 2),
 284 #else
 285   D(MajorSubsystemVersion,"__major_subsystem_version__", 4),
 286 #endif
 287   D(MinorSubsystemVersion,"__minor_subsystem_version__", 0),
 288   D(Subsystem,"__subsystem__", ${SUBSYSTEM}),
 289   D(SizeOfStackReserve,"__size_of_stack_reserve__", 0x200000),
 290   D(SizeOfStackCommit,"__size_of_stack_commit__", 0x1000),
 291   D(SizeOfHeapReserve,"__size_of_heap_reserve__", 0x100000),
 292   D(SizeOfHeapCommit,"__size_of_heap_commit__", 0x1000),
 293   D(LoaderFlags,"__loader_flags__", 0x0),
 294   { NULL, 0, 0, NULL, 0 }
 295 };
 296
 297
 298 static void
 299 gld_${EMULATION_NAME}_list_options (FILE *file)
 300 {
 301   fprintf (file, _("  --base_file <basefile>             Generate a base file for relocatable DLLs\n"));
 302   fprintf (file, _("  --dll                              Set image base to the default for DLLs\n"));
 303   fprintf (file, _("  --file-alignment <size>            Set file alignment\n"));
 304   fprintf (file, _("  --heap <size>                      Set initial size of the heap\n"));
 305   fprintf (file, _("  --image-base <address>             Set start address of the executable\n"));
 306   fprintf (file, _("  --major-image-version <number>     Set version number of the executable\n"));
 307   fprintf (file, _("  --major-os-version <number>        Set minimum required OS version\n"));
 308   fprintf (file, _("  --major-subsystem-version <number> Set minimum required OS subsystem version\n"));
 309   fprintf (file, _("  --minor-image-version <number>     Set revision number of the executable\n"));
 310   fprintf (file, _("  --minor-os-version <number>        Set minimum required OS revision\n"));
 311   fprintf (file, _("  --minor-subsystem-version <number> Set minimum required OS subsystem revision\n"));
 312   fprintf (file, _("  --section-alignment <size>         Set section alignment\n"));
 313   fprintf (file, _("  --stack <size>                     Set size of the initial stack\n"));
 314   fprintf (file, _("  --subsystem <name>[:<version>]     Set required OS subsystem [& version]\n"));
 315   fprintf (file, _("  --support-old-code                 Support interworking with old code\n"));
 316   fprintf (file, _("  --thumb-entry=<symbol>             Set the entry point to be Thumb <symbol>\n"));
 317 #ifdef DLL_SUPPORT
 318   fprintf (file, _("  --add-stdcall-alias                Export symbols with and without @nn\n"));
 319   fprintf (file, _("  --disable-stdcall-fixup            Don't link _sym to _sym@nn\n"));
 320   fprintf (file, _("  --enable-stdcall-fixup             Link _sym to _sym@nn without warnings\n"));
 321   fprintf (file, _("  --exclude-symbols sym,sym,...      Exclude symbols from automatic export\n"));
 322   fprintf (file, _("  --exclude-libs lib,lib,...         Exclude libraries from automatic export\n"));
 323   fprintf (file, _("  --export-all-symbols               Automatically export all globals to DLL\n"));
 324   fprintf (file, _("  --kill-at                          Remove @nn from exported symbols\n"));
 325   fprintf (file, _("  --out-implib <file>                Generate import library\n"));
 326   fprintf (file, _("  --output-def <file>                Generate a .DEF file for the built DLL\n"));
 327   fprintf (file, _("  --warn-duplicate-exports           Warn about duplicate exports.\n"));
 328   fprintf (file, _("  --compat-implib                    Create backward compatible import libs;\n\
 329                                        create __imp_<SYMBOL> as well.\n"));
 330   fprintf (file, _("  --enable-auto-image-base           Automatically choose image base for DLLs\n\
 331                                        unless user specifies one\n"));
 332   fprintf (file, _("  --disable-auto-image-base          Do not auto-choose image base. (default)\n"));
 333   fprintf (file, _("  --dll-search-prefix=<string>       When linking dynamically to a dll without\n\
 334                                        an importlib, use <string><basename>.dll\n\
 335                                        in preference to lib<basename>.dll \n"));
 336   fprintf (file, _("  --enable-auto-import               Do sophistcated linking of _sym to\n\
 337                                        __imp_sym for DATA references\n"));
 338   fprintf (file, _("  --disable-auto-import              Do not auto-import DATA items from DLLs\n"));
 339   fprintf (file, _("  --enable-runtime-pseudo-reloc      Work around auto-import limitations by\n\
 340                                        adding pseudo-relocations resolved at\n\
 341                                        runtime.\n"));
 342   fprintf (file, _("  --disable-runtime-pseudo-reloc     Do not add runtime pseudo-relocations for\n\
 343                                        auto-imported DATA.\n"));
 344   fprintf (file, _("  --enable-extra-pe-debug            Enable verbose debug output when building\n\
 345                                        or linking to DLLs (esp. auto-import)\n"));
 346 #endif
 347   fprintf (file, _("  --large-address-aware              Executable supports virtual addresses\n\
 348                                        greater than 2 gigabytes\n"));
 349 }
 350
 351
 352 static void
 353 set_pe_name (char *name, long val)
 354 {
 355   int i;
 356
 357   /* Find the name and set it.  */
 358   for (i = 0; init[i].ptr; i++)
 359     {
 360       if (strcmp (name, init[i].symbol) == 0)
 361         {
 362           init[i].value = val;
 363           init[i].inited = 1;
 364           return;
 365         }
 366     }
 367   abort ();
 368 }
 369
 370
 371 static void
 372 set_pe_subsystem (void)
 373 {
 374   const char *sver;
 375   const char *entry;
 376   const char *initial_symbol_char;
 377   char *end;
 378   int len;
 379   int i;
 380   int subsystem;
 381   unsigned long temp_subsystem;
 382   static const struct
 383     {
 384       const char *name;
 385       const int value;
 386       const char *entry;
 387     }
 388   v[] =
 389     {
 390       { "native",  1, "NtProcessStartup" },
 391       { "windows", 2, "WinMainCRTStartup" },
 392       { "console", 3, "mainCRTStartup" },
 393       { "posix",   7, "__PosixProcessStartup"},
 394       { "wince",   9, "_WinMainCRTStartup" },
 395       { "xbox",   14, "mainCRTStartup" },
 396       { NULL, 0, NULL }
 397     };
 398   /* Entry point name for arbitrary subsystem numbers.  */
 399   static const char default_entry[] = "mainCRTStartup";
 400
 401   /* Check for the presence of a version number.  */
 402   sver = strchr (optarg, ':');
 403   if (sver == NULL)
 404     len = strlen (optarg);
 405   else
 406     {
 407       len = sver - optarg;
 408       set_pe_name ("__major_subsystem_version__",
 409                    strtoul (sver + 1, &end, 0));
 410       if (*end == '.')
 411         set_pe_name ("__minor_subsystem_version__",
 412                      strtoul (end + 1, &end, 0));
 413       if (*end != '\0')
 414         einfo (_("%P: warning: bad version number in -subsystem option\n"));
 415     }
 416
 417   /* Check for numeric subsystem.  */
 418   temp_subsystem = strtoul (optarg, & end, 0);
 419   if ((*end == ':' || *end == '\0') && (temp_subsystem < 65536))
 420     {
 421       /* Search list for a numeric match to use its entry point.  */
 422       for (i = 0; v[i].name; i++)
 423         if (v[i].value == (int) temp_subsystem)
 424           break;
 425
 426       /* If no match, use the default.  */
 427       if (v[i].name != NULL)
 428         entry = v[i].entry;
 429       else
 430         entry = default_entry;
 431
 432       /* Use this subsystem.  */
 433       subsystem = (int) temp_subsystem;
 434     }
 435   else
 436     {
 437       /* Search for subsystem by name.  */
 438       for (i = 0; v[i].name; i++)
 439         if (strncmp (optarg, v[i].name, len) == 0
 440             && v[i].name[len] == '\0')
 441           break;
 442
 443       if (v[i].name == NULL)
 444         {
 445           einfo (_("%P%F: invalid subsystem type %s\n"), optarg);
 446           return;
 447         }
 448
 449       entry = v[i].entry;
 450       subsystem = v[i].value;
 451     }
 452
 453   set_pe_name ("__subsystem__", subsystem);
 454
 455   initial_symbol_char = ${INITIAL_SYMBOL_CHAR};
 456   if (*initial_symbol_char != '\0')
 457     {
 458       char *alc_entry;
 459
 460       /* lang_add_entry expects its argument to be permanently
 461          allocated, so we don't free this string.  */
 462       alc_entry = xmalloc (strlen (initial_symbol_char)
 463                            + strlen (entry)
 464                            + 1);
 465       strcpy (alc_entry, initial_symbol_char);
 466       strcat (alc_entry, entry);
 467       entry = alc_entry;
 468     }
 469
 470   lang_add_entry (entry, FALSE);
 471
 472   return;
 473 }
 474
 475
 476 static void
 477 set_pe_value (char *name)
 478 {
 479   char *end;
 480
 481   set_pe_name (name,  strtoul (optarg, &end, 0));
 482
 483   if (end == optarg)
 484     einfo (_("%P%F: invalid hex number for PE parameter '%s'\n"), optarg);
 485
 486   optarg = end;
 487 }
 488
 489
 490 static void
 491 set_pe_stack_heap (char *resname, char *comname)
 492 {
 493   set_pe_value (resname);
 494
 495   if (*optarg == ',')
 496     {
 497       optarg++;
 498       set_pe_value (comname);
 499     }
 500   else if (*optarg)
 501     einfo (_("%P%F: strange hex info for PE parameter '%s'\n"), optarg);
 502 }
 503
 504
 505 static bfd_boolean
 506 gld${EMULATION_NAME}_handle_option (int optc)
 507 {
 508   switch (optc)
 509     {
 510     default:
 511       return FALSE;
 512
 513     case OPTION_BASE_FILE:
 514       link_info.base_file = fopen (optarg, FOPEN_WB);
 515       if (link_info.base_file == NULL)
 516         {
 517           /* xgettext:c-format */
 518           fprintf (stderr, _("%s: Can't open base file %s\n"),
 519                    program_name, optarg);
 520           xexit (1);
 521         }
 522       break;
 523
 524       /* PE options.  */
 525     case OPTION_HEAP:
 526       set_pe_stack_heap ("__size_of_heap_reserve__", "__size_of_heap_commit__");
 527       break;
 528     case OPTION_STACK:
 529       set_pe_stack_heap ("__size_of_stack_reserve__", "__size_of_stack_commit__");
 530       break;
 531     case OPTION_SUBSYSTEM:
 532       set_pe_subsystem ();
 533       break;
 534     case OPTION_MAJOR_OS_VERSION:
 535       set_pe_value ("__major_os_version__");
 536       break;
 537     case OPTION_MINOR_OS_VERSION:
 538       set_pe_value ("__minor_os_version__");
 539       break;
 540     case OPTION_MAJOR_SUBSYSTEM_VERSION:
 541       set_pe_value ("__major_subsystem_version__");
 542       break;
 543     case OPTION_MINOR_SUBSYSTEM_VERSION:
 544       set_pe_value ("__minor_subsystem_version__");
 545       break;
 546     case OPTION_MAJOR_IMAGE_VERSION:
 547       set_pe_value ("__major_image_version__");
 548       break;
 549     case OPTION_MINOR_IMAGE_VERSION:
 550       set_pe_value ("__minor_image_version__");
 551       break;
 552     case OPTION_FILE_ALIGNMENT:
 553       set_pe_value ("__file_alignment__");
 554       break;
 555     case OPTION_SECTION_ALIGNMENT:
 556       set_pe_value ("__section_alignment__");
 557       break;
 558     case OPTION_DLL:
 559       set_pe_name ("__dll__", 1);
 560       break;
 561     case OPTION_IMAGE_BASE:
 562       set_pe_value ("__image_base__");
 563       break;
 564     case OPTION_SUPPORT_OLD_CODE:
 565       support_old_code = 1;
 566       break;
 567     case OPTION_THUMB_ENTRY:
 568       thumb_entry_symbol = optarg;
 569       break;
 570 #ifdef DLL_SUPPORT
 571     case OPTION_OUT_DEF:
 572       pe_out_def_filename = xstrdup (optarg);
 573       break;
 574     case OPTION_EXPORT_ALL:
 575       pe_dll_export_everything = 1;
 576       break;
 577     case OPTION_EXCLUDE_SYMBOLS:
 578       pe_dll_add_excludes (optarg, 0);
 579       break;
 580     case OPTION_EXCLUDE_LIBS:
 581       pe_dll_add_excludes (optarg, 1);
 582       break;
 583     case OPTION_KILL_ATS:
 584       pe_dll_kill_ats = 1;
 585       break;
 586     case OPTION_STDCALL_ALIASES:
 587       pe_dll_stdcall_aliases = 1;
 588       break;
 589     case OPTION_ENABLE_STDCALL_FIXUP:
 590       pe_enable_stdcall_fixup = 1;
 591       break;
 592     case OPTION_DISABLE_STDCALL_FIXUP:
 593       pe_enable_stdcall_fixup = 0;
 594       break;
 595     case OPTION_IMPLIB_FILENAME:
 596       pe_implib_filename = xstrdup (optarg);
 597       break;
 598     case OPTION_WARN_DUPLICATE_EXPORTS:
 599       pe_dll_warn_dup_exports = 1;
 600       break;
 601     case OPTION_IMP_COMPAT:
 602       pe_dll_compat_implib = 1;
 603       break;
 604     case OPTION_ENABLE_AUTO_IMAGE_BASE:
 605       pe_enable_auto_image_base = 1;
 606       break;
 607     case OPTION_DISABLE_AUTO_IMAGE_BASE:
 608       pe_enable_auto_image_base = 0;
 609       break;
 610     case OPTION_DLL_SEARCH_PREFIX:
 611       pe_dll_search_prefix = xstrdup (optarg);
 612       break;
 613     case OPTION_NO_DEFAULT_EXCLUDES:
 614       pe_dll_do_default_excludes = 0;
 615       break;
 616     case OPTION_DLL_ENABLE_AUTO_IMPORT:
 617       link_info.pei386_auto_import = 1;
 618       break;
 619     case OPTION_DLL_DISABLE_AUTO_IMPORT:
 620       link_info.pei386_auto_import = 0;
 621       break;
 622     case OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC:
 623       link_info.pei386_runtime_pseudo_reloc = 1;
 624       break;
 625     case OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC:
 626       link_info.pei386_runtime_pseudo_reloc = 0;
 627       break;
 628     case OPTION_ENABLE_EXTRA_PE_DEBUG:
 629       pe_dll_extra_pe_debug = 1;
 630       break;
 631 #endif
 632     case OPTION_LARGE_ADDRESS_AWARE:
 633       real_flags |= IMAGE_FILE_LARGE_ADDRESS_AWARE;
 634       break;
 635     }
 636   return TRUE;
 637 }
 638 \f
 639
 640 #ifdef DLL_SUPPORT
 641 static unsigned long
 642 strhash (const char *str)
 643 {
 644   const unsigned char *s;
 645   unsigned long hash;
 646   unsigned int c;
 647   unsigned int len;
 648
 649   hash = 0;
 650   len = 0;
 651   s = (const unsigned char *) str;
 652   while ((c = *s++) != '\0')
 653     {
 654       hash += c + (c << 17);
 655       hash ^= hash >> 2;
 656       ++len;
 657     }
 658   hash += len + (len << 17);
 659   hash ^= hash >> 2;
 660
 661   return hash;
 662 }
 663
 664 /* Use the output file to create a image base for relocatable DLLs.  */
 665
 666 static unsigned long
 667 compute_dll_image_base (const char *ofile)
 668 {
 669   unsigned long hash = strhash (ofile);
 670   return 0x60000000 | ((hash << 16) & 0x0FFC0000);
 671 }
 672 #endif
 673
 674 /* Assign values to the special symbols before the linker script is
 675    read.  */
 676
 677 static void
 678 gld_${EMULATION_NAME}_set_symbols (void)
 679 {
 680   /* Run through and invent symbols for all the
 681      names and insert the defaults.  */
 682   int j;
 683   lang_statement_list_type *save;
 684
 685   if (!init[IMAGEBASEOFF].inited)
 686     {
 687       if (link_info.relocatable)
 688         init[IMAGEBASEOFF].value = 0;
 689       else if (init[DLLOFF].value || (link_info.shared && !link_info.pie))
 690 #ifdef DLL_SUPPORT
 691         init[IMAGEBASEOFF].value = (pe_enable_auto_image_base) ?
 692           compute_dll_image_base (output_filename) : NT_DLL_IMAGE_BASE;
 693 #else
 694         init[IMAGEBASEOFF].value = NT_DLL_IMAGE_BASE;
 695 #endif
 696       else
 697         init[IMAGEBASEOFF].value = NT_EXE_IMAGE_BASE;
 698     }
 699
 700   /* Don't do any symbol assignments if this is a relocatable link.  */
 701   if (link_info.relocatable)
 702     return;
 703
 704   /* Glue the assignments into the abs section.  */
 705   save = stat_ptr;
 706
 707   stat_ptr = &(abs_output_section->children);
 708
 709   for (j = 0; init[j].ptr; j++)
 710     {
 711       long val = init[j].value;
 712       lang_assignment_statement_type *rv;
 713       rv = lang_add_assignment (exp_assop ('=', init[j].symbol,
 714                                            exp_intop (val)));
 715       if (init[j].size == sizeof (short))
 716         *(short *) init[j].ptr = val;
 717       else if (init[j].size == sizeof (int))
 718         *(int *) init[j].ptr = val;
 719       else if (init[j].size == sizeof (long))
 720         *(long *) init[j].ptr = val;
 721       /* This might be a long long or other special type.  */
 722       else if (init[j].size == sizeof (bfd_vma))
 723         *(bfd_vma *) init[j].ptr = val;
 724       else      abort ();
 725       if (j == IMAGEBASEOFF)
 726         image_base_statement = rv;
 727     }
 728   /* Restore the pointer.  */
 729   stat_ptr = save;
 730
 731   if (pe.FileAlignment >
 732       pe.SectionAlignment)
 733     {
 734       einfo (_("%P: warning, file alignment > section alignment.\n"));
 735     }
 736 }
 737
 738 /* This is called after the linker script and the command line options
 739    have been read.  */
 740
 741 static void
 742 gld_${EMULATION_NAME}_after_parse (void)
 743 {
 744   /* The Windows libraries are designed for the linker to treat the
 745      entry point as an undefined symbol.  Otherwise, the .obj that
 746      defines mainCRTStartup is brought in because it is the first
 747      encountered in libc.lib and it has other symbols in it which will
 748      be pulled in by the link process.  To avoid this, we act as
 749      though the user specified -u with the entry point symbol.
 750
 751      This function is called after the linker script and command line
 752      options have been read, so at this point we know the right entry
 753      point.  This function is called before the input files are
 754      opened, so registering the symbol as undefined will make a
 755      difference.  */
 756
 757   if (! link_info.relocatable && entry_symbol.name != NULL)
 758     ldlang_add_undef (entry_symbol.name);
 759 }
 760
 761 /* pe-dll.c directly accesses pe_data_import_dll,
 762    so it must be defined outside of #ifdef DLL_SUPPORT.
 763    Note - this variable is deliberately not initialised.
 764    This allows it to be treated as a common varaible, and only
 765    exist in one incarnation in a multiple target enabled linker.  */
 766 char * pe_data_import_dll;
 767
 768 #ifdef DLL_SUPPORT
 769 static struct bfd_link_hash_entry *pe_undef_found_sym;
 770
 771 static bfd_boolean
 772 pe_undef_cdecl_match (struct bfd_link_hash_entry *h, void *inf)
 773 {
 774   int sl;
 775   char *string = inf;
 776
 777   sl = strlen (string);
 778   if (h->type == bfd_link_hash_defined
 779       && strncmp (h->root.string, string, sl) == 0
 780       && h->root.string[sl] == '@')
 781     {
 782       pe_undef_found_sym = h;
 783       return FALSE;
 784     }
 785   return TRUE;
 786 }
 787
 788 static void
 789 pe_fixup_stdcalls (void)
 790 {
 791   static int gave_warning_message = 0;
 792   struct bfd_link_hash_entry *undef, *sym;
 793
 794   if (pe_dll_extra_pe_debug)
 795     printf ("%s\n", __FUNCTION__);
 796
 797   for (undef = link_info.hash->undefs; undef; undef=undef->u.undef.next)
 798     if (undef->type == bfd_link_hash_undefined)
 799       {
 800         char* at = strchr (undef->root.string, '@');
 801         int lead_at = (*undef->root.string == '@');
 802         /* For now, don't try to fixup fastcall symbols.  */
 803
 804         if (at && !lead_at)
 805           {
 806             /* The symbol is a stdcall symbol, so let's look for a
 807                cdecl symbol with the same name and resolve to that.  */
 808             char *cname = xstrdup (undef->root.string /* + lead_at */);
 809             at = strchr (cname, '@');
 810             *at = 0;
 811             sym = bfd_link_hash_lookup (link_info.hash, cname, 0, 0, 1);
 812
 813             if (sym && sym->type == bfd_link_hash_defined)
 814               {
 815                 undef->type = bfd_link_hash_defined;
 816                 undef->u.def.value = sym->u.def.value;
 817                 undef->u.def.section = sym->u.def.section;
 818
 819                 if (pe_enable_stdcall_fixup == -1)
 820                   {
 821                     einfo (_("Warning: resolving %s by linking to %s\n"),
 822                            undef->root.string, cname);
 823                     if (! gave_warning_message)
 824                       {
 825                         gave_warning_message = 1;
 826                         einfo (_("Use --enable-stdcall-fixup to disable these warnings\n"));
 827                         einfo (_("Use --disable-stdcall-fixup to disable these fixups\n"));
 828                       }
 829                   }
 830               }
 831           }
 832         else
 833           {
 834             /* The symbol is a cdecl symbol, so we look for stdcall
 835                symbols - which means scanning the whole symbol table.  */
 836             pe_undef_found_sym = 0;
 837             bfd_link_hash_traverse (link_info.hash, pe_undef_cdecl_match,
 838                                     (char *) undef->root.string);
 839             sym = pe_undef_found_sym;
 840             if (sym)
 841               {
 842                 undef->type = bfd_link_hash_defined;
 843                 undef->u.def.value = sym->u.def.value;
 844                 undef->u.def.section = sym->u.def.section;
 845
 846                 if (pe_enable_stdcall_fixup == -1)
 847                   {
 848                     einfo (_("Warning: resolving %s by linking to %s\n"),
 849                            undef->root.string, sym->root.string);
 850                     if (! gave_warning_message)
 851                       {
 852                         gave_warning_message = 1;
 853                         einfo (_("Use --enable-stdcall-fixup to disable these warnings\n"));
 854                         einfo (_("Use --disable-stdcall-fixup to disable these fixups\n"));
 855                       }
 856                   }
 857               }
 858           }
 859       }
 860 }
 861
 862 static int
 863 make_import_fixup (arelent *rel, asection *s)
 864 {
 865   struct bfd_symbol *sym = *rel->sym_ptr_ptr;
 866   char addend[4];
 867
 868   if (pe_dll_extra_pe_debug)
 869     printf ("arelent: %s@%#lx: add=%li\n", sym->name,
 870             (long) rel->address, (long) rel->addend);
 871
 872   if (! bfd_get_section_contents (s->owner, s, addend, rel->address, sizeof (addend)))
 873     einfo (_("%C: Cannot get section contents - auto-import exception\n"),
 874            s->owner, s, rel->address);
 875
 876   pe_create_import_fixup (rel, s, bfd_get_32 (s->owner, addend));
 877
 878   return 1;
 879 }
 880
 881 static void
 882 pe_find_data_imports (void)
 883 {
 884   struct bfd_link_hash_entry *undef, *sym;
 885
 886   if (link_info.pei386_auto_import == 0)
 887     return;
 888
 889   for (undef = link_info.hash->undefs; undef; undef=undef->u.undef.next)
 890     {
 891       if (undef->type == bfd_link_hash_undefined)
 892         {
 893           /* C++ symbols are *long*.  */
 894           char buf[4096];
 895
 896           if (pe_dll_extra_pe_debug)
 897             printf ("%s:%s\n", __FUNCTION__, undef->root.string);
 898
 899           sprintf (buf, "__imp_%s", undef->root.string);
 900
 901           sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
 902
 903           if (sym && sym->type == bfd_link_hash_defined)
 904             {
 905               bfd *b = sym->u.def.section->owner;
 906               asymbol **symbols;
 907               int nsyms, symsize, i;
 908
 909               if (link_info.pei386_auto_import == -1)
 910                 info_msg (_("Info: resolving %s by linking to %s (auto-import)\n"),
 911                           undef->root.string, buf);
 912
 913               symsize = bfd_get_symtab_upper_bound (b);
 914               symbols = (asymbol **) xmalloc (symsize);
 915               nsyms = bfd_canonicalize_symtab (b, symbols);
 916
 917               for (i = 0; i < nsyms; i++)
 918                 {
 919                   if (memcmp (symbols[i]->name, "__head_",
 920                               sizeof ("__head_") - 1))
 921                     continue;
 922
 923                   if (pe_dll_extra_pe_debug)
 924                     printf ("->%s\n", symbols[i]->name);
 925
 926                   pe_data_import_dll = (char*) (symbols[i]->name +
 927                                                 sizeof ("__head_") - 1);
 928                   break;
 929                 }
 930
 931               pe_walk_relocs_of_symbol (&link_info, undef->root.string,
 932                                         make_import_fixup);
 933
 934               /* Let's differentiate it somehow from defined.  */
 935               undef->type = bfd_link_hash_defweak;
 936               /* We replace original name with __imp_ prefixed, this
 937                  1) may trash memory 2) leads to duplicate symbol generation.
 938                  Still, IMHO it's better than having name poluted.  */
 939               undef->root.string = sym->root.string;
 940               undef->u.def.value = sym->u.def.value;
 941               undef->u.def.section = sym->u.def.section;
 942             }
 943         }
 944     }
 945 }
 946
 947 static bfd_boolean
 948 pr_sym (struct bfd_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
 949 {
 950   if (pe_dll_extra_pe_debug)
 951     printf ("+%s\n", h->string);
 952
 953   return TRUE;
 954 }
 955 #endif /* DLL_SUPPORT */
 956
 957
 958 static void
 959 gld_${EMULATION_NAME}_after_open (void)
 960 {
 961 #ifdef DLL_SUPPORT
 962   if (pe_dll_extra_pe_debug)
 963     {
 964       bfd *a;
 965       struct bfd_link_hash_entry *sym;
 966
 967       printf ("%s()\n", __FUNCTION__);
 968
 969       for (sym = link_info.hash->undefs; sym; sym=sym->u.undef.next)
 970         printf ("-%s\n", sym->root.string);
 971       bfd_hash_traverse (&link_info.hash->table, pr_sym, NULL);
 972
 973       for (a = link_info.input_bfds; a; a = a->link_next)
 974         printf ("*%s\n",a->filename);
 975     }
 976 #endif
 977
 978   /* Pass the wacky PE command line options into the output bfd.
 979      FIXME: This should be done via a function, rather than by
 980      including an internal BFD header.  */
 981
 982   if (coff_data (output_bfd) == NULL || coff_data (output_bfd)->pe == 0)
 983     einfo (_("%F%P: PE operations on non PE file.\n"));
 984
 985   pe_data (output_bfd)->pe_opthdr = pe;
 986   pe_data (output_bfd)->dll = init[DLLOFF].value;
 987   pe_data (output_bfd)->real_flags |= real_flags;
 988
 989 #ifdef DLL_SUPPORT
 990   if (pe_enable_stdcall_fixup) /* -1=warn or 1=disable */
 991     pe_fixup_stdcalls ();
 992
 993   pe_process_import_defs (output_bfd, & link_info);
 994
 995   pe_find_data_imports ();
 996
 997 #if ! (defined (TARGET_IS_i386pe) || defined (TARGET_IS_armpe))
 998   if (link_info.shared)
 999 #else
1000   if (!link_info.relocatable)
1001 #endif
1002     pe_dll_build_sections (output_bfd, &link_info);
1003
1004 #ifndef TARGET_IS_i386pe
1005 #ifndef TARGET_IS_armpe
1006   else
1007     pe_exe_build_sections (output_bfd, &link_info);
1008 #endif
1009 #endif
1010 #endif
1011
1012 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
1013   if (strstr (bfd_get_target (output_bfd), "arm") == NULL)
1014     {
1015       /* The arm backend needs special fields in the output hash structure.
1016          These will only be created if the output format is an arm format,
1017          hence we do not support linking and changing output formats at the
1018          same time.  Use a link followed by objcopy to change output formats.  */
1019       einfo ("%F%X%P: error: cannot change output format whilst linking ARM binaries\n");
1020       return;
1021     }
1022   {
1023     /* Find a BFD that can hold the interworking stubs.  */
1024     LANG_FOR_EACH_INPUT_STATEMENT (is)
1025       {
1026         if (bfd_arm_pe_get_bfd_for_interworking (is->the_bfd, & link_info))
1027           break;
1028       }
1029   }
1030 #endif
1031
1032   {
1033     /* This next chunk of code tries to detect the case where you have
1034        two import libraries for the same DLL (specifically,
1035        symbolically linking libm.a and libc.a in cygwin to
1036        libcygwin.a).  In those cases, it's possible for function
1037        thunks from the second implib to be used but without the
1038        head/tail objects, causing an improper import table.  We detect
1039        those cases and rename the "other" import libraries to match
1040        the one the head/tail come from, so that the linker will sort
1041        things nicely and produce a valid import table.  */
1042
1043     LANG_FOR_EACH_INPUT_STATEMENT (is)
1044       {
1045         if (is->the_bfd->my_archive)
1046           {
1047             int idata2 = 0, reloc_count=0, is_imp = 0;
1048             asection *sec;
1049
1050             /* See if this is an import library thunk.  */
1051             for (sec = is->the_bfd->sections; sec; sec = sec->next)
1052               {
1053                 if (strcmp (sec->name, ".idata\$2") == 0)
1054                   idata2 = 1;
1055                 if (strncmp (sec->name, ".idata\$", 7) == 0)
1056                   is_imp = 1;
1057                 reloc_count += sec->reloc_count;
1058               }
1059
1060             if (is_imp && !idata2 && reloc_count)
1061               {
1062                 /* It is, look for the reference to head and see if it's
1063                    from our own library.  */
1064                 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1065                   {
1066                     int i;
1067                     long symsize;
1068                     long relsize;
1069                     asymbol **symbols;
1070                     arelent **relocs;
1071                     int nrelocs;
1072
1073                     symsize = bfd_get_symtab_upper_bound (is->the_bfd);
1074                     if (symsize < 1)
1075                       break;
1076                     relsize = bfd_get_reloc_upper_bound (is->the_bfd, sec);
1077                     if (relsize < 1)
1078                       break;
1079
1080                     symbols = (asymbol **) xmalloc (symsize);
1081                     symsize = bfd_canonicalize_symtab (is->the_bfd, symbols);
1082                     if (symsize < 0)
1083                       {
1084                         einfo ("%X%P: unable to process symbols: %E");
1085                         return;
1086                       }
1087
1088                     relocs = (arelent **) xmalloc ((size_t) relsize);
1089                     nrelocs = bfd_canonicalize_reloc (is->the_bfd, sec,
1090                                                       relocs, symbols);
1091                     if (nrelocs < 0)
1092                       {
1093                         free (relocs);
1094                         einfo ("%X%P: unable to process relocs: %E");
1095                         return;
1096                       }
1097
1098                     for (i = 0; i < nrelocs; i++)
1099                       {
1100                         struct bfd_symbol *s;
1101                         struct bfd_link_hash_entry * blhe;
1102                         char *other_bfd_filename;
1103                         char *n;
1104
1105                         s = (relocs[i]->sym_ptr_ptr)[0];
1106
1107                         if (s->flags & BSF_LOCAL)
1108                           continue;
1109
1110                         /* Thunk section with reloc to another bfd.  */
1111                         blhe = bfd_link_hash_lookup (link_info.hash,
1112                                                      s->name,
1113                                                      FALSE, FALSE, TRUE);
1114
1115                         if (blhe == NULL
1116                             || blhe->type != bfd_link_hash_defined)
1117                           continue;
1118
1119                         other_bfd_filename
1120                           = blhe->u.def.section->owner->my_archive
1121                             ? bfd_get_filename (blhe->u.def.section->owner->my_archive)
1122                             : bfd_get_filename (blhe->u.def.section->owner);
1123
1124                         if (strcmp (bfd_get_filename (is->the_bfd->my_archive),
1125                                     other_bfd_filename) == 0)
1126                           continue;
1127
1128                         /* Rename this implib to match the other one.  */
1129                         n = xmalloc (strlen (other_bfd_filename) + 1);
1130                         strcpy (n, other_bfd_filename);
1131                         is->the_bfd->my_archive->filename = n;
1132                       }
1133
1134                     free (relocs);
1135                     /* Note - we do not free the symbols,
1136                        they are now cached in the BFD.  */
1137                   }
1138               }
1139           }
1140       }
1141   }
1142
1143   {
1144     int is_ms_arch = 0;
1145     bfd *cur_arch = 0;
1146     lang_input_statement_type *is2;
1147     lang_input_statement_type *is3;
1148
1149     /* Careful - this is a shell script.  Watch those dollar signs! */
1150     /* Microsoft import libraries have every member named the same,
1151        and not in the right order for us to link them correctly.  We
1152        must detect these and rename the members so that they'll link
1153        correctly.  There are three types of objects: the head, the
1154        thunks, and the sentinel(s).  The head is easy; it's the one
1155        with idata2.  We assume that the sentinels won't have relocs,
1156        and the thunks will.  It's easier than checking the symbol
1157        table for external references.  */
1158     LANG_FOR_EACH_INPUT_STATEMENT (is)
1159       {
1160         if (is->the_bfd->my_archive)
1161           {
1162             char *pnt;
1163             bfd *arch = is->the_bfd->my_archive;
1164
1165             if (cur_arch != arch)
1166               {
1167                 cur_arch = arch;
1168                 is_ms_arch = 1;
1169
1170                 for (is3 = is;
1171                      is3 && is3->the_bfd->my_archive == arch;
1172                      is3 = (lang_input_statement_type *) is3->next)
1173                   {
1174                     /* A MS dynamic import library can also contain static
1175                        members, so look for the first element with a .dll
1176                        extension, and use that for the remainder of the
1177                        comparisons.  */
1178                     pnt = strrchr (is3->the_bfd->filename, '.');
1179                     if (pnt != NULL && strcmp (pnt, ".dll") == 0)
1180                       break;
1181                   }
1182
1183                 if (is3 == NULL)
1184                   is_ms_arch = 0;
1185                 else
1186                   {
1187                     /* OK, found one.  Now look to see if the remaining
1188                        (dynamic import) members use the same name.  */
1189                     for (is2 = is;
1190                          is2 && is2->the_bfd->my_archive == arch;
1191                          is2 = (lang_input_statement_type *) is2->next)
1192                       {
1193                         /* Skip static members, ie anything with a .obj
1194                            extension.  */
1195                         pnt = strrchr (is2->the_bfd->filename, '.');
1196                         if (pnt != NULL && strcmp (pnt, ".obj") == 0)
1197                           continue;
1198
1199                         if (strcmp (is3->the_bfd->filename,
1200                                     is2->the_bfd->filename))
1201                           {
1202                             is_ms_arch = 0;
1203                             break;
1204                           }
1205                       }
1206                   }
1207               }
1208
1209             /* This fragment might have come from an .obj file in a Microsoft
1210                import, and not an actual import record. If this is the case,
1211                then leave the filename alone.  */
1212             pnt = strrchr (is->the_bfd->filename, '.');
1213
1214             if (is_ms_arch && (strcmp (pnt, ".dll") == 0))
1215               {
1216                 int idata2 = 0, reloc_count=0;
1217                 asection *sec;
1218                 char *new_name, seq;
1219
1220                 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1221                   {
1222                     if (strcmp (sec->name, ".idata\$2") == 0)
1223                       idata2 = 1;
1224                     reloc_count += sec->reloc_count;
1225                   }
1226
1227                 if (idata2) /* .idata2 is the TOC */
1228                   seq = 'a';
1229                 else if (reloc_count > 0) /* thunks */
1230                   seq = 'b';
1231                 else /* sentinel */
1232                   seq = 'c';
1233
1234                 new_name = xmalloc (strlen (is->the_bfd->filename) + 3);
1235                 sprintf (new_name, "%s.%c", is->the_bfd->filename, seq);
1236                 is->the_bfd->filename = new_name;
1237
1238                 new_name = xmalloc (strlen (is->filename) + 3);
1239                 sprintf (new_name, "%s.%c", is->filename, seq);
1240                 is->filename = new_name;
1241               }
1242           }
1243       }
1244   }
1245 }
1246 \f
1247 static void
1248 gld_${EMULATION_NAME}_before_allocation (void)
1249 {
1250 #ifdef TARGET_IS_ppcpe
1251   /* Here we rummage through the found bfds to collect toc information.  */
1252   {
1253     LANG_FOR_EACH_INPUT_STATEMENT (is)
1254       {
1255         if (!ppc_process_before_allocation (is->the_bfd, &link_info))
1256           {
1257             /* xgettext:c-format */
1258             einfo (_("Errors encountered processing file %s\n"), is->filename);
1259           }
1260       }
1261   }
1262
1263   /* We have seen it all. Allocate it, and carry on.  */
1264   ppc_allocate_toc_section (&link_info);
1265 #endif /* TARGET_IS_ppcpe */
1266
1267 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
1268   /* FIXME: we should be able to set the size of the interworking stub
1269      section.
1270
1271      Here we rummage through the found bfds to collect glue
1272      information.  FIXME: should this be based on a command line
1273      option?  krk@cygnus.com.  */
1274   {
1275     LANG_FOR_EACH_INPUT_STATEMENT (is)
1276       {
1277         if (! bfd_arm_pe_process_before_allocation
1278             (is->the_bfd, & link_info, support_old_code))
1279           {
1280             /* xgettext:c-format */
1281             einfo (_("Errors encountered processing file %s for interworking"),
1282                    is->filename);
1283           }
1284       }
1285   }
1286
1287   /* We have seen it all. Allocate it, and carry on.  */
1288   bfd_arm_pe_allocate_interworking_sections (& link_info);
1289 #endif /* TARGET_IS_armpe */
1290
1291   if (!link_info.relocatable)
1292     strip_excluded_output_sections ();
1293 }
1294 \f
1295 #ifdef DLL_SUPPORT
1296 /* This is called when an input file isn't recognized as a BFD.  We
1297    check here for .DEF files and pull them in automatically.  */
1298
1299 static int
1300 saw_option (char *option)
1301 {
1302   int i;
1303
1304   for (i = 0; init[i].ptr; i++)
1305     if (strcmp (init[i].symbol, option) == 0)
1306       return init[i].inited;
1307   return 0;
1308 }
1309 #endif /* DLL_SUPPORT */
1310
1311 static bfd_boolean
1312 gld_${EMULATION_NAME}_unrecognized_file (lang_input_statement_type *entry ATTRIBUTE_UNUSED)
1313 {
1314 #ifdef DLL_SUPPORT
1315   const char *ext = entry->filename + strlen (entry->filename) - 4;
1316
1317   if (strcmp (ext, ".def") == 0 || strcmp (ext, ".DEF") == 0)
1318     {
1319       pe_def_file = def_file_parse (entry->filename, pe_def_file);
1320
1321       if (pe_def_file)
1322         {
1323           int i, buflen=0, len;
1324           char *buf;
1325
1326           for (i = 0; i < pe_def_file->num_exports; i++)
1327             {
1328               len = strlen (pe_def_file->exports[i].internal_name);
1329               if (buflen < len + 2)
1330                 buflen = len + 2;
1331             }
1332
1333           buf = (char *) xmalloc (buflen);
1334
1335           for (i = 0; i < pe_def_file->num_exports; i++)
1336             {
1337               struct bfd_link_hash_entry *h;
1338
1339               sprintf (buf, "_%s", pe_def_file->exports[i].internal_name);
1340
1341               h = bfd_link_hash_lookup (link_info.hash, buf, TRUE, TRUE, TRUE);
1342               if (h == (struct bfd_link_hash_entry *) NULL)
1343                 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1344               if (h->type == bfd_link_hash_new)
1345                 {
1346                   h->type = bfd_link_hash_undefined;
1347                   h->u.undef.abfd = NULL;
1348                   bfd_link_add_undef (link_info.hash, h);
1349                 }
1350             }
1351           free (buf);
1352
1353           /* def_file_print (stdout, pe_def_file); */
1354           if (pe_def_file->is_dll == 1)
1355             link_info.shared = 1;
1356
1357           if (pe_def_file->base_address != (bfd_vma)(-1))
1358             {
1359               pe.ImageBase =
1360                 pe_data (output_bfd)->pe_opthdr.ImageBase =
1361                 init[IMAGEBASEOFF].value = pe_def_file->base_address;
1362               init[IMAGEBASEOFF].inited = 1;
1363               if (image_base_statement)
1364                 image_base_statement->exp =
1365                   exp_assop ('=', "__image_base__", exp_intop (pe.ImageBase));
1366             }
1367
1368           if (pe_def_file->stack_reserve != -1
1369               && ! saw_option ("__size_of_stack_reserve__"))
1370             {
1371               pe.SizeOfStackReserve = pe_def_file->stack_reserve;
1372               if (pe_def_file->stack_commit != -1)
1373                 pe.SizeOfStackCommit = pe_def_file->stack_commit;
1374             }
1375           if (pe_def_file->heap_reserve != -1
1376               && ! saw_option ("__size_of_heap_reserve__"))
1377             {
1378               pe.SizeOfHeapReserve = pe_def_file->heap_reserve;
1379               if (pe_def_file->heap_commit != -1)
1380                 pe.SizeOfHeapCommit = pe_def_file->heap_commit;
1381             }
1382           return TRUE;
1383         }
1384     }
1385 #endif
1386   return FALSE;
1387 }
1388
1389 static bfd_boolean
1390 gld_${EMULATION_NAME}_recognized_file (lang_input_statement_type *entry ATTRIBUTE_UNUSED)
1391 {
1392 #ifdef DLL_SUPPORT
1393 #ifdef TARGET_IS_i386pe
1394   pe_dll_id_target ("pei-i386");
1395 #endif
1396 #ifdef TARGET_IS_shpe
1397   pe_dll_id_target ("pei-shl");
1398 #endif
1399 #ifdef TARGET_IS_mipspe
1400   pe_dll_id_target ("pei-mips");
1401 #endif
1402 #ifdef TARGET_IS_armpe
1403   pe_dll_id_target ("pei-arm-little");
1404 #endif
1405   if (bfd_get_format (entry->the_bfd) == bfd_object)
1406     {
1407       char fbuf[LD_PATHMAX + 1];
1408       const char *ext;
1409
1410       if (REALPATH (entry->filename, fbuf) == NULL)
1411         strncpy (fbuf, entry->filename, sizeof (fbuf));
1412
1413       ext = fbuf + strlen (fbuf) - 4;
1414
1415       if (strcmp (ext, ".dll") == 0 || strcmp (ext, ".DLL") == 0)
1416         return pe_implied_import_dll (fbuf);
1417     }
1418 #endif
1419   return FALSE;
1420 }
1421
1422 static void
1423 gld_${EMULATION_NAME}_finish (void)
1424 {
1425 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
1426   struct bfd_link_hash_entry * h;
1427
1428   if (thumb_entry_symbol != NULL)
1429     {
1430       h = bfd_link_hash_lookup (link_info.hash, thumb_entry_symbol,
1431                                 FALSE, FALSE, TRUE);
1432
1433       if (h != (struct bfd_link_hash_entry *) NULL
1434           && (h->type == bfd_link_hash_defined
1435               || h->type == bfd_link_hash_defweak)
1436           && h->u.def.section->output_section != NULL)
1437         {
1438           static char buffer[32];
1439           bfd_vma val;
1440
1441           /* Special procesing is required for a Thumb entry symbol.  The
1442              bottom bit of its address must be set.  */
1443           val = (h->u.def.value
1444                  + bfd_get_section_vma (output_bfd,
1445                                         h->u.def.section->output_section)
1446                  + h->u.def.section->output_offset);
1447
1448           val |= 1;
1449
1450           /* Now convert this value into a string and store it in entry_symbol
1451              where the lang_finish() function will pick it up.  */
1452           buffer[0] = '0';
1453           buffer[1] = 'x';
1454
1455           sprintf_vma (buffer + 2, val);
1456
1457           if (entry_symbol.name != NULL && entry_from_cmdline)
1458             einfo (_("%P: warning: '--thumb-entry %s' is overriding '-e %s'\n"),
1459                    thumb_entry_symbol, entry_symbol.name);
1460           entry_symbol.name = buffer;
1461         }
1462       else
1463         einfo (_("%P: warning: connot find thumb start symbol %s\n"), thumb_entry_symbol);
1464     }
1465 #endif /* defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe) */
1466
1467 #ifdef DLL_SUPPORT
1468   if (link_info.shared
1469 #if !defined(TARGET_IS_shpe) && !defined(TARGET_IS_mipspe)
1470     || (!link_info.relocatable && pe_def_file->num_exports != 0)
1471 #endif
1472     )
1473     {
1474       pe_dll_fill_sections (output_bfd, &link_info);
1475       if (pe_implib_filename)
1476         pe_dll_generate_implib (pe_def_file, pe_implib_filename);
1477     }
1478 #if defined(TARGET_IS_shpe) || defined(TARGET_IS_mipspe)
1479   /* ARM doesn't need relocs.  */
1480   else
1481     {
1482       pe_exe_fill_sections (output_bfd, &link_info);
1483     }
1484 #endif
1485
1486   if (pe_out_def_filename)
1487     pe_dll_generate_def_file (pe_out_def_filename);
1488 #endif /* DLL_SUPPORT */
1489
1490   /* I don't know where .idata gets set as code, but it shouldn't be.  */
1491   {
1492     asection *asec = bfd_get_section_by_name (output_bfd, ".idata");
1493
1494     if (asec)
1495       {
1496         asec->flags &= ~SEC_CODE;
1497         asec->flags |= SEC_DATA;
1498       }
1499   }
1500 }
1501
1502 \f
1503 /* Place an orphan section.
1504
1505    We use this to put sections in a reasonable place in the file, and
1506    to ensure that they are aligned as required.
1507
1508    We handle grouped sections here as well.  A section named .foo$nn
1509    goes into the output section .foo.  All grouped sections are sorted
1510    by name.
1511
1512    Grouped sections for the default sections are handled by the
1513    default linker script using wildcards, and are sorted by
1514    sort_sections.  */
1515
1516 static bfd_boolean
1517 gld_${EMULATION_NAME}_place_orphan (lang_input_statement_type *file, asection *s)
1518 {
1519   const char *secname;
1520   const char *orig_secname;
1521   char *dollar = NULL;
1522   lang_output_section_statement_type *os;
1523   lang_statement_list_type add_child;
1524
1525   secname = bfd_get_section_name (s->owner, s);
1526
1527   /* Look through the script to see where to place this section.  */
1528   orig_secname = secname;
1529   if (!link_info.relocatable
1530       && (dollar = strchr (secname, '$')) != NULL)
1531     {
1532       size_t len = dollar - orig_secname;
1533       char *newname = xmalloc (len + 1);
1534       memcpy (newname, orig_secname, len);
1535       newname[len] = '\0';
1536       secname = newname;
1537     }
1538
1539   os = lang_output_section_find (secname);
1540
1541   lang_list_init (&add_child);
1542
1543   if (os != NULL
1544       && (os->bfd_section == NULL
1545           || os->bfd_section->flags == 0
1546           || ((s->flags ^ os->bfd_section->flags)
1547               & (SEC_LOAD | SEC_ALLOC)) == 0))
1548     {
1549       /* We already have an output section statement with this
1550          name, and its bfd section, if any, has compatible flags.
1551          If the section already exists but does not have any flags set,
1552          then it has been created by the linker, probably as a result of
1553          a --section-start command line switch.  */
1554       lang_add_section (&add_child, s, os, file);
1555     }
1556   else
1557     {
1558       static struct orphan_save hold[] =
1559         {
1560           { ".text",
1561             SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE,
1562             0, 0, 0, 0 },
1563           { ".rdata",
1564             SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1565             0, 0, 0, 0 },
1566           { ".data",
1567             SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA,
1568             0, 0, 0, 0 },
1569           { ".bss",
1570             SEC_ALLOC,
1571             0, 0, 0, 0 }
1572         };
1573       enum orphan_save_index
1574         {
1575           orphan_text = 0,
1576           orphan_rodata,
1577           orphan_data,
1578           orphan_bss
1579         };
1580       static int orphan_init_done = 0;
1581       struct orphan_save *place;
1582       lang_output_section_statement_type *after;
1583       etree_type *address;
1584
1585       if (!orphan_init_done)
1586         {
1587           struct orphan_save *ho;
1588           for (ho = hold; ho < hold + sizeof (hold) / sizeof (hold[0]); ++ho)
1589             if (ho->name != NULL)
1590               {
1591                 ho->os = lang_output_section_find (ho->name);
1592                 if (ho->os != NULL && ho->os->flags == 0)
1593                   ho->os->flags = ho->flags;
1594               }
1595           orphan_init_done = 1;
1596         }
1597
1598       /* Try to put the new output section in a reasonable place based
1599          on the section name and section flags.  */
1600
1601       place = NULL;
1602       if ((s->flags & SEC_ALLOC) == 0)
1603         ;
1604       else if ((s->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
1605         place = &hold[orphan_bss];
1606       else if ((s->flags & SEC_READONLY) == 0)
1607         place = &hold[orphan_data];
1608       else if ((s->flags & SEC_CODE) == 0)
1609         place = &hold[orphan_rodata];
1610       else
1611         place = &hold[orphan_text];
1612
1613       after = NULL;
1614       if (place != NULL)
1615         {
1616           if (place->os == NULL)
1617             place->os = lang_output_section_find (place->name);
1618           after = place->os;
1619           if (after == NULL)
1620             after = lang_output_section_find_by_flags (s, &place->os);
1621           if (after == NULL)
1622             /* *ABS* is always the first output section statement.  */
1623             after = (&lang_output_section_statement.head
1624                      ->output_section_statement);
1625         }
1626
1627       /* Choose a unique name for the section.  This will be needed if the
1628          same section name appears in the input file with different
1629          loadable or allocatable characteristics.  */
1630       if (bfd_get_section_by_name (output_bfd, secname) != NULL)
1631         {
1632           static int count = 1;
1633           secname = bfd_get_unique_section_name (output_bfd, secname, &count);
1634           if (secname == NULL)
1635             einfo ("%F%P: place_orphan failed: %E\n");
1636         }
1637
1638       /* All sections in an executable must be aligned to a page boundary.  */
1639       address = exp_unop (ALIGN_K, exp_nameop (NAME, "__section_alignment__"));
1640       os = lang_insert_orphan (file, s, secname, after, place, address,
1641                                &add_child);
1642     }
1643
1644   {
1645     lang_statement_union_type **pl = &os->children.head;
1646
1647     if (dollar != NULL)
1648       {
1649         bfd_boolean found_dollar;
1650
1651         /* The section name has a '$'.  Sort it with the other '$'
1652            sections.  */
1653         found_dollar = FALSE;
1654         for ( ; *pl != NULL; pl = &(*pl)->header.next)
1655           {
1656             lang_input_section_type *ls;
1657             const char *lname;
1658
1659             if ((*pl)->header.type != lang_input_section_enum)
1660               continue;
1661
1662             ls = &(*pl)->input_section;
1663
1664             lname = bfd_get_section_name (ls->ifile->the_bfd, ls->section);
1665             if (strchr (lname, '$') == NULL)
1666               {
1667                 if (found_dollar)
1668                   break;
1669               }
1670             else
1671               {
1672                 found_dollar = TRUE;
1673                 if (strcmp (orig_secname, lname) < 0)
1674                   break;
1675               }
1676           }
1677       }
1678
1679     if (add_child.head != NULL)
1680       {
1681         add_child.head->header.next = *pl;
1682         *pl = add_child.head;
1683       }
1684   }
1685
1686   return TRUE;
1687 }
1688
1689 static bfd_boolean
1690 gld_${EMULATION_NAME}_open_dynamic_archive
1691   (const char *arch ATTRIBUTE_UNUSED, search_dirs_type *search,
1692    lang_input_statement_type *entry)
1693 {
1694   const char * filename;
1695   char * string;
1696
1697   if (! entry->is_archive)
1698     return FALSE;
1699
1700   filename = entry->filename;
1701
1702   string = (char *) xmalloc (strlen (search->name)
1703                              + strlen (filename)
1704                              + sizeof "/lib.a.dll"
1705 #ifdef DLL_SUPPORT
1706                              + (pe_dll_search_prefix ? strlen (pe_dll_search_prefix) : 0)
1707 #endif
1708                              + 1);
1709
1710   /* Try "libfoo.dll.a" first (preferred explicit import library for dll's.  */
1711   sprintf (string, "%s/lib%s.dll.a", search->name, filename);
1712
1713   if (! ldfile_try_open_bfd (string, entry))
1714     {
1715       /* Try "foo.dll.a" next (alternate explicit import library for dll's.  */
1716       sprintf (string, "%s/%s.dll.a", search->name, filename);
1717       if (! ldfile_try_open_bfd (string, entry))
1718         {
1719           /* Try libfoo.a next. Normally, this would be interpreted as a static
1720              library, but it *could* be an import library. For backwards compatibility,
1721              libfoo.a needs to ==precede== libfoo.dll and foo.dll in the search,
1722              or sometimes errors occur when building legacy packages.
1723
1724              Putting libfoo.a here means that in a failure case (i.e. the library
1725              -lfoo is not found) we will search for libfoo.a twice before
1726              giving up -- once here, and once when searching for a "static" lib.
1727              for a "static" lib.  */
1728           /* Try "libfoo.a" (import lib, or static lib, but must
1729              take precedence over dll's).  */
1730           sprintf (string, "%s/lib%s.a", search->name, filename);
1731           if (! ldfile_try_open_bfd (string, entry))
1732             {
1733 #ifdef DLL_SUPPORT
1734               if (pe_dll_search_prefix)
1735                 {
1736                   /* Try "<prefix>foo.dll" (preferred dll name, if specified).  */
1737                   sprintf (string, "%s/%s%s.dll", search->name, pe_dll_search_prefix, filename);
1738                   if (! ldfile_try_open_bfd (string, entry))
1739                     {
1740                       /* Try "libfoo.dll" (default preferred dll name).  */
1741                       sprintf (string, "%s/lib%s.dll", search->name, filename);
1742                       if (! ldfile_try_open_bfd (string, entry))
1743                         {
1744                           /* Finally, try "foo.dll" (alternate dll name).  */
1745                           sprintf (string, "%s/%s.dll", search->name, filename);
1746                           if (! ldfile_try_open_bfd (string, entry))
1747                             {
1748                               free (string);
1749                               return FALSE;
1750                             }
1751                         }
1752                     }
1753                 }
1754               else /* pe_dll_search_prefix not specified.  */
1755 #endif
1756                 {
1757                   /* Try "libfoo.dll" (preferred dll name).  */
1758                   sprintf (string, "%s/lib%s.dll", search->name, filename);
1759                   if (! ldfile_try_open_bfd (string, entry))
1760                     {
1761                       /* Finally, try "foo.dll" (alternate dll name).  */
1762                       sprintf (string, "%s/%s.dll", search->name, filename);
1763                       if (! ldfile_try_open_bfd (string, entry))
1764                         {
1765                           free (string);
1766                           return FALSE;
1767                         }
1768                     }
1769                 }
1770             }
1771         }
1772     }
1773
1774   entry->filename = string;
1775
1776   return TRUE;
1777 }
1778
1779 static int
1780 gld_${EMULATION_NAME}_find_potential_libraries
1781   (char *name, lang_input_statement_type *entry)
1782 {
1783   return ldfile_open_file_search (name, entry, "", ".lib");
1784 }
1785 \f
1786 static char *
1787 gld_${EMULATION_NAME}_get_script (int *isfile)
1788 EOF
1789 # Scripts compiled in.
1790 # sed commands to quote an ld script as a C string.
1791 sc="-f stringify.sed"
1792
1793 cat >>e${EMULATION_NAME}.c <<EOF
1794 {
1795   *isfile = 0;
1796
1797   if (link_info.relocatable && config.build_constructors)
1798     return
1799 EOF
1800 sed $sc ldscripts/${EMULATION_NAME}.xu                  >> e${EMULATION_NAME}.c
1801 echo '  ; else if (link_info.relocatable) return'       >> e${EMULATION_NAME}.c
1802 sed $sc ldscripts/${EMULATION_NAME}.xr                  >> e${EMULATION_NAME}.c
1803 echo '  ; else if (!config.text_read_only) return'      >> e${EMULATION_NAME}.c
1804 sed $sc ldscripts/${EMULATION_NAME}.xbn                 >> e${EMULATION_NAME}.c
1805 echo '  ; else if (!config.magic_demand_paged) return'  >> e${EMULATION_NAME}.c
1806 sed $sc ldscripts/${EMULATION_NAME}.xn                  >> e${EMULATION_NAME}.c
1807 echo '  ; else return'                                  >> e${EMULATION_NAME}.c
1808 sed $sc ldscripts/${EMULATION_NAME}.x                   >> e${EMULATION_NAME}.c
1809 echo '; }'                                              >> e${EMULATION_NAME}.c
1810
1811 cat >>e${EMULATION_NAME}.c <<EOF
1812
1813
1814 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1815 {
1816   gld_${EMULATION_NAME}_before_parse,
1817   syslib_default,
1818   hll_default,
1819   gld_${EMULATION_NAME}_after_parse,
1820   gld_${EMULATION_NAME}_after_open,
1821   after_allocation_default,
1822   set_output_arch_default,
1823   ldemul_default_target,
1824   gld_${EMULATION_NAME}_before_allocation,
1825   gld_${EMULATION_NAME}_get_script,
1826   "${EMULATION_NAME}",
1827   "${OUTPUT_FORMAT}",
1828   gld_${EMULATION_NAME}_finish,
1829   NULL, /* Create output section statements.  */
1830   gld_${EMULATION_NAME}_open_dynamic_archive,
1831   gld_${EMULATION_NAME}_place_orphan,
1832   gld_${EMULATION_NAME}_set_symbols,
1833   NULL, /* parse_args */
1834   gld${EMULATION_NAME}_add_options,
1835   gld${EMULATION_NAME}_handle_option,
1836   gld_${EMULATION_NAME}_unrecognized_file,
1837   gld_${EMULATION_NAME}_list_options,
1838   gld_${EMULATION_NAME}_recognized_file,
1839   gld_${EMULATION_NAME}_find_potential_libraries,
1840   NULL  /* new_vers_pattern.  */
1841 };
1842 EOF