ld/emultempl/pe.em

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