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