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