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_find_data_imports ();
1013
1014   pe_process_import_defs(output_bfd, &link_info);
1015   if (link_info.shared)
1016     pe_dll_build_sections (output_bfd, &link_info);
1017
1018 #ifndef TARGET_IS_i386pe
1019 #ifndef TARGET_IS_armpe
1020   else
1021     pe_exe_build_sections (output_bfd, &link_info);
1022 #endif
1023 #endif
1024 #endif
1025
1026 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
1027   if (strstr (bfd_get_target (output_bfd), "arm") == NULL)
1028     {
1029       /* The arm backend needs special fields in the output hash structure.
1030          These will only be created if the output format is an arm format,
1031          hence we do not support linking and changing output formats at the
1032          same time.  Use a link followed by objcopy to change output formats.  */
1033       einfo ("%F%X%P: error: cannot change output format whilst linking ARM binaries\n");
1034       return;
1035     }
1036   {
1037     /* Find a BFD that can hold the interworking stubs.  */
1038     LANG_FOR_EACH_INPUT_STATEMENT (is)
1039       {
1040         if (bfd_arm_pe_get_bfd_for_interworking (is->the_bfd, & link_info))
1041           break;
1042       }
1043   }
1044 #endif
1045
1046   {
1047     /* This next chunk of code tries to detect the case where you have
1048        two import libraries for the same DLL (specifically,
1049        symbolically linking libm.a and libc.a in cygwin to
1050        libcygwin.a).  In those cases, it's possible for function
1051        thunks from the second implib to be used but without the
1052        head/tail objects, causing an improper import table.  We detect
1053        those cases and rename the "other" import libraries to match
1054        the one the head/tail come from, so that the linker will sort
1055        things nicely and produce a valid import table. */
1056
1057     LANG_FOR_EACH_INPUT_STATEMENT (is)
1058       {
1059         if (is->the_bfd->my_archive)
1060           {
1061             int idata2 = 0, reloc_count=0, is_imp = 0;
1062             asection *sec;
1063
1064             /* See if this is an import library thunk.  */
1065             for (sec = is->the_bfd->sections; sec; sec = sec->next)
1066               {
1067                 if (strcmp (sec->name, ".idata\$2") == 0)
1068                   idata2 = 1;
1069                 if (strncmp (sec->name, ".idata\$", 7) == 0)
1070                   is_imp = 1;
1071                 reloc_count += sec->reloc_count;
1072               }
1073
1074             if (is_imp && !idata2 && reloc_count)
1075               {
1076                 /* It is, look for the reference to head and see if it's
1077                    from our own library.  */
1078                 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1079                   {
1080                     int i;
1081                     long symsize;
1082                     long relsize;
1083                     asymbol **symbols;
1084                     arelent **relocs;
1085                     int nrelocs;
1086
1087                     symsize = bfd_get_symtab_upper_bound (is->the_bfd);
1088                     if (symsize < 1)
1089                       break;
1090                     relsize = bfd_get_reloc_upper_bound (is->the_bfd, sec);
1091                     if (relsize < 1)
1092                       break;
1093
1094                     symbols = (asymbol **) xmalloc (symsize);
1095                     symsize = bfd_canonicalize_symtab (is->the_bfd, symbols);
1096                     if (symsize < 0)
1097                       {
1098                         einfo ("%X%P: unable to process symbols: %E");
1099                         return;
1100                       }
1101
1102                     relocs = (arelent **) xmalloc ((size_t) relsize);
1103                     nrelocs = bfd_canonicalize_reloc (is->the_bfd, sec,
1104                                                           relocs, symbols);
1105                     if (nrelocs < 0)
1106                       {
1107                         free (relocs);
1108                         einfo ("%X%P: unable to process relocs: %E");
1109                         return;
1110                       }
1111
1112                     for (i = 0; i < nrelocs; i++)
1113                       {
1114                         struct symbol_cache_entry *s;
1115                         struct bfd_link_hash_entry * blhe;
1116                         bfd *other_bfd;
1117                         char *n;
1118
1119                         s = (relocs[i]->sym_ptr_ptr)[0];
1120
1121                         if (s->flags & BSF_LOCAL)
1122                           continue;
1123
1124                         /* Thunk section with reloc to another bfd.  */
1125                         blhe = bfd_link_hash_lookup (link_info.hash,
1126                                                      s->name,
1127                                                      FALSE, FALSE, TRUE);
1128
1129                         if (blhe == NULL
1130                             || blhe->type != bfd_link_hash_defined)
1131                           continue;
1132
1133                         other_bfd = blhe->u.def.section->owner;
1134
1135                         if (strcmp (is->the_bfd->my_archive->filename,
1136                                     other_bfd->my_archive->filename) == 0)
1137                           continue;
1138
1139                         /* Rename this implib to match the other.  */
1140                         n = (char *) xmalloc (strlen (other_bfd->my_archive->filename) + 1);
1141
1142                         strcpy (n, other_bfd->my_archive->filename);
1143
1144                         is->the_bfd->my_archive->filename = n;
1145                       }
1146
1147                     free (relocs);
1148                     /* Note - we do not free the symbols,
1149                        they are now cached in the BFD.  */
1150                   }
1151               }
1152           }
1153       }
1154   }
1155
1156   {
1157     int is_ms_arch = 0;
1158     bfd *cur_arch = 0;
1159     lang_input_statement_type *is2;
1160
1161     /* Careful - this is a shell script.  Watch those dollar signs! */
1162     /* Microsoft import libraries have every member named the same,
1163        and not in the right order for us to link them correctly.  We
1164        must detect these and rename the members so that they'll link
1165        correctly.  There are three types of objects: the head, the
1166        thunks, and the sentinel(s).  The head is easy; it's the one
1167        with idata2.  We assume that the sentinels won't have relocs,
1168        and the thunks will.  It's easier than checking the symbol
1169        table for external references.  */
1170     LANG_FOR_EACH_INPUT_STATEMENT (is)
1171       {
1172         if (is->the_bfd->my_archive)
1173           {
1174             bfd *arch = is->the_bfd->my_archive;
1175             if (cur_arch != arch)
1176               {
1177                 cur_arch = arch;
1178                 is_ms_arch = 1;
1179                 for (is2 = is;
1180                      is2 && is2->the_bfd->my_archive == arch;
1181                      is2 = (lang_input_statement_type *)is2->next)
1182                   {
1183                     if (strcmp (is->the_bfd->filename, is2->the_bfd->filename))
1184                       is_ms_arch = 0;
1185                   }
1186               }
1187
1188             if (is_ms_arch)
1189               {
1190                 int idata2 = 0, reloc_count=0;
1191                 asection *sec;
1192                 char *new_name, seq;
1193
1194                 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1195                   {
1196                     if (strcmp (sec->name, ".idata\$2") == 0)
1197                       idata2 = 1;
1198                     reloc_count += sec->reloc_count;
1199                   }
1200
1201                 if (idata2) /* .idata2 is the TOC */
1202                   seq = 'a';
1203                 else if (reloc_count > 0) /* thunks */
1204                   seq = 'b';
1205                 else /* sentinel */
1206                   seq = 'c';
1207
1208                 new_name = xmalloc (strlen (is->the_bfd->filename) + 3);
1209                 sprintf (new_name, "%s.%c", is->the_bfd->filename, seq);
1210                 is->the_bfd->filename = new_name;
1211
1212                 new_name = xmalloc (strlen (is->filename) + 3);
1213                 sprintf (new_name, "%s.%c", is->filename, seq);
1214                 is->filename = new_name;
1215               }
1216           }
1217       }
1218   }
1219 }
1220 \f
1221 static void
1222 gld_${EMULATION_NAME}_before_allocation()
1223 {
1224 #ifdef TARGET_IS_ppcpe
1225   /* Here we rummage through the found bfds to collect toc information.  */
1226   {
1227     LANG_FOR_EACH_INPUT_STATEMENT (is)
1228       {
1229         if (!ppc_process_before_allocation (is->the_bfd, &link_info))
1230           {
1231             /* xgettext:c-format */
1232             einfo (_("Errors encountered processing file %s\n"), is->filename);
1233           }
1234       }
1235   }
1236
1237   /* We have seen it all. Allocate it, and carry on.  */
1238   ppc_allocate_toc_section (&link_info);
1239 #endif /* TARGET_IS_ppcpe */
1240
1241 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
1242   /* FIXME: we should be able to set the size of the interworking stub
1243      section.
1244
1245      Here we rummage through the found bfds to collect glue
1246      information.  FIXME: should this be based on a command line
1247      option?  krk@cygnus.com.  */
1248   {
1249     LANG_FOR_EACH_INPUT_STATEMENT (is)
1250       {
1251         if (! bfd_arm_pe_process_before_allocation
1252             (is->the_bfd, & link_info, support_old_code))
1253           {
1254             /* xgettext:c-format */
1255             einfo (_("Errors encountered processing file %s for interworking"),
1256                    is->filename);
1257           }
1258       }
1259   }
1260
1261   /* We have seen it all. Allocate it, and carry on.  */
1262   bfd_arm_pe_allocate_interworking_sections (& link_info);
1263 #endif /* TARGET_IS_armpe */
1264 }
1265 \f
1266 #ifdef DLL_SUPPORT
1267 /* This is called when an input file isn't recognized as a BFD.  We
1268    check here for .DEF files and pull them in automatically.  */
1269
1270 static int
1271 saw_option (char * option)
1272 {
1273   int i;
1274
1275   for (i = 0; init[i].ptr; i++)
1276     if (strcmp (init[i].symbol, option) == 0)
1277       return init[i].inited;
1278   return 0;
1279 }
1280 #endif /* DLL_SUPPORT */
1281
1282 static bfd_boolean
1283 gld_${EMULATION_NAME}_unrecognized_file(entry)
1284      lang_input_statement_type *entry ATTRIBUTE_UNUSED;
1285 {
1286 #ifdef DLL_SUPPORT
1287   const char *ext = entry->filename + strlen (entry->filename) - 4;
1288
1289   if (strcmp (ext, ".def") == 0 || strcmp (ext, ".DEF") == 0)
1290     {
1291       if (pe_def_file == 0)
1292         pe_def_file = def_file_empty ();
1293
1294       def_file_parse (entry->filename, pe_def_file);
1295
1296       if (pe_def_file)
1297         {
1298           int i, buflen=0, len;
1299           char *buf;
1300
1301           for (i = 0; i < pe_def_file->num_exports; i++)
1302             {
1303               len = strlen(pe_def_file->exports[i].internal_name);
1304               if (buflen < len + 2)
1305                 buflen = len + 2;
1306             }
1307
1308           buf = (char *) xmalloc (buflen);
1309
1310           for (i = 0; i < pe_def_file->num_exports; i++)
1311             {
1312               struct bfd_link_hash_entry *h;
1313
1314               sprintf(buf, "_%s", pe_def_file->exports[i].internal_name);
1315
1316               h = bfd_link_hash_lookup (link_info.hash, buf, TRUE, TRUE, TRUE);
1317               if (h == (struct bfd_link_hash_entry *) NULL)
1318                 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1319               if (h->type == bfd_link_hash_new)
1320                 {
1321                   h->type = bfd_link_hash_undefined;
1322                   h->u.undef.abfd = NULL;
1323                   bfd_link_add_undef (link_info.hash, h);
1324                 }
1325             }
1326           free (buf);
1327
1328           /* def_file_print (stdout, pe_def_file); */
1329           if (pe_def_file->is_dll == 1)
1330             link_info.shared = 1;
1331
1332           if (pe_def_file->base_address != (bfd_vma)(-1))
1333             {
1334               pe.ImageBase =
1335                 pe_data (output_bfd)->pe_opthdr.ImageBase =
1336                 init[IMAGEBASEOFF].value = pe_def_file->base_address;
1337               init[IMAGEBASEOFF].inited = 1;
1338               if (image_base_statement)
1339                 image_base_statement->exp =
1340                   exp_assop ('=', "__image_base__", exp_intop (pe.ImageBase));
1341             }
1342
1343 #if 0
1344           /* Not sure if these *should* be set */
1345           if (pe_def_file->version_major != -1)
1346             {
1347               pe.MajorImageVersion = pe_def_file->version_major;
1348               pe.MinorImageVersion = pe_def_file->version_minor;
1349             }
1350 #endif
1351           if (pe_def_file->stack_reserve != -1
1352               && ! saw_option ("__size_of_stack_reserve__"))
1353             {
1354               pe.SizeOfStackReserve = pe_def_file->stack_reserve;
1355               if (pe_def_file->stack_commit != -1)
1356                 pe.SizeOfStackCommit = pe_def_file->stack_commit;
1357             }
1358           if (pe_def_file->heap_reserve != -1
1359               && ! saw_option ("__size_of_heap_reserve__"))
1360             {
1361               pe.SizeOfHeapReserve = pe_def_file->heap_reserve;
1362               if (pe_def_file->heap_commit != -1)
1363                 pe.SizeOfHeapCommit = pe_def_file->heap_commit;
1364             }
1365           return TRUE;
1366         }
1367     }
1368 #endif
1369   return FALSE;
1370 }
1371
1372 static bfd_boolean
1373 gld_${EMULATION_NAME}_recognized_file(entry)
1374   lang_input_statement_type *entry ATTRIBUTE_UNUSED;
1375 {
1376 #ifdef DLL_SUPPORT
1377 #ifdef TARGET_IS_i386pe
1378   pe_dll_id_target ("pei-i386");
1379 #endif
1380 #ifdef TARGET_IS_shpe
1381   pe_dll_id_target ("pei-shl");
1382 #endif
1383 #ifdef TARGET_IS_mipspe
1384   pe_dll_id_target ("pei-mips");
1385 #endif
1386 #ifdef TARGET_IS_armpe
1387   pe_dll_id_target ("pei-arm-little");
1388 #endif
1389   if (bfd_get_format (entry->the_bfd) == bfd_object)
1390     {
1391       const char *ext = entry->filename + strlen (entry->filename) - 4;
1392
1393       if (strcmp (ext, ".dll") == 0 || strcmp (ext, ".DLL") == 0)
1394         return pe_implied_import_dll (entry->filename);
1395     }
1396 #endif
1397   return FALSE;
1398 }
1399
1400 static void
1401 gld_${EMULATION_NAME}_finish ()
1402 {
1403 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe)
1404   struct bfd_link_hash_entry * h;
1405
1406   if (thumb_entry_symbol != NULL)
1407     {
1408       h = bfd_link_hash_lookup (link_info.hash, thumb_entry_symbol,
1409                                 FALSE, FALSE, TRUE);
1410
1411       if (h != (struct bfd_link_hash_entry *) NULL
1412           && (h->type == bfd_link_hash_defined
1413               || h->type == bfd_link_hash_defweak)
1414           && h->u.def.section->output_section != NULL)
1415         {
1416           static char buffer[32];
1417           bfd_vma val;
1418
1419           /* Special procesing is required for a Thumb entry symbol.  The
1420              bottom bit of its address must be set.  */
1421           val = (h->u.def.value
1422                  + bfd_get_section_vma (output_bfd,
1423                                         h->u.def.section->output_section)
1424                  + h->u.def.section->output_offset);
1425
1426           val |= 1;
1427
1428           /* Now convert this value into a string and store it in entry_symbol
1429              where the lang_finish() function will pick it up.  */
1430           buffer[0] = '0';
1431           buffer[1] = 'x';
1432
1433           sprintf_vma (buffer + 2, val);
1434
1435           if (entry_symbol.name != NULL && entry_from_cmdline)
1436             einfo (_("%P: warning: '--thumb-entry %s' is overriding '-e %s'\n"),
1437                    thumb_entry_symbol, entry_symbol.name);
1438           entry_symbol.name = buffer;
1439         }
1440       else
1441         einfo (_("%P: warning: connot find thumb start symbol %s\n"), thumb_entry_symbol);
1442     }
1443 #endif /* defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe) */
1444
1445 #ifdef DLL_SUPPORT
1446   if (link_info.shared)
1447     {
1448       pe_dll_fill_sections (output_bfd, &link_info);
1449       if (pe_implib_filename)
1450         pe_dll_generate_implib (pe_def_file, pe_implib_filename);
1451     }
1452 #if defined(TARGET_IS_shpe) || defined(TARGET_IS_mipspe)
1453   /* ARM doesn't need relocs.  */
1454   else
1455     {
1456       pe_exe_fill_sections (output_bfd, &link_info);
1457     }
1458 #endif
1459
1460   if (pe_out_def_filename)
1461     pe_dll_generate_def_file (pe_out_def_filename);
1462 #endif /* DLL_SUPPORT */
1463
1464   /* I don't know where .idata gets set as code, but it shouldn't be.  */
1465   {
1466     asection *asec = bfd_get_section_by_name (output_bfd, ".idata");
1467
1468     if (asec)
1469       {
1470         asec->flags &= ~SEC_CODE;
1471         asec->flags |= SEC_DATA;
1472       }
1473   }
1474 }
1475
1476 \f
1477 /* Find the last output section before given output statement.
1478    Used by place_orphan.  */
1479
1480 static asection *
1481 output_prev_sec_find (os)
1482      lang_output_section_statement_type *os;
1483 {
1484   asection *s = (asection *) NULL;
1485   lang_statement_union_type *u;
1486   lang_output_section_statement_type *lookup;
1487
1488   for (u = lang_output_section_statement.head;
1489        u != (lang_statement_union_type *) NULL;
1490        u = lookup->next)
1491     {
1492       lookup = &u->output_section_statement;
1493       if (lookup == os)
1494         return s;
1495
1496       if (lookup->bfd_section != NULL && lookup->bfd_section->owner != NULL)
1497         s = lookup->bfd_section;
1498     }
1499
1500   return NULL;
1501 }
1502
1503 /* Place an orphan section.
1504
1505    We use this to put sections in a reasonable place in the file, and
1506    to ensure that they are aligned as required.
1507
1508    We handle grouped sections here as well.  A section named .foo$nn
1509    goes into the output section .foo.  All grouped sections are sorted
1510    by name.
1511
1512    Grouped sections for the default sections are handled by the
1513    default linker script using wildcards, and are sorted by
1514    sort_sections.  */
1515
1516 struct orphan_save
1517 {
1518   lang_output_section_statement_type *os;
1519   asection **section;
1520   lang_statement_union_type **stmt;
1521 };
1522
1523 static bfd_boolean
1524 gld_${EMULATION_NAME}_place_orphan (file, s)
1525      lang_input_statement_type *file;
1526      asection *s;
1527 {
1528   const char *secname;
1529   char *hold_section_name;
1530   char *dollar = NULL;
1531   const char *ps = NULL;
1532   lang_output_section_statement_type *os;
1533   lang_statement_list_type add_child;
1534
1535   secname = bfd_get_section_name (s->owner, s);
1536
1537   /* Look through the script to see where to place this section.  */
1538   hold_section_name = xstrdup (secname);
1539   if (!link_info.relocateable)
1540     {
1541       dollar = strchr (hold_section_name, '$');
1542       if (dollar != NULL)
1543         *dollar = '\0';
1544     }
1545
1546   os = lang_output_section_find (hold_section_name);
1547
1548   lang_list_init (&add_child);
1549
1550   if (os != NULL
1551       && (os->bfd_section == NULL
1552           || ((s->flags ^ os->bfd_section->flags)
1553               & (SEC_LOAD | SEC_ALLOC)) == 0))
1554     {
1555       /* We already have an output section statement with this
1556          name, and its bfd section, if any, has compatible flags.  */
1557       lang_add_section (&add_child, s, os, file);
1558     }
1559   else
1560     {
1561       struct orphan_save *place;
1562       static struct orphan_save hold_text;
1563       static struct orphan_save hold_rdata;
1564       static struct orphan_save hold_data;
1565       static struct orphan_save hold_bss;
1566       char *outsecname;
1567       lang_statement_list_type *old;
1568       lang_statement_list_type add;
1569       etree_type *address;
1570
1571       /* Try to put the new output section in a reasonable place based
1572          on the section name and section flags.  */
1573 #define HAVE_SECTION(hold, name) \
1574 (hold.os != NULL || (hold.os = lang_output_section_find (name)) != NULL)
1575
1576       place = NULL;
1577       if ((s->flags & SEC_ALLOC) == 0)
1578         ;
1579       else if ((s->flags & SEC_HAS_CONTENTS) == 0
1580                && HAVE_SECTION (hold_bss, ".bss"))
1581         place = &hold_bss;
1582       else if ((s->flags & SEC_READONLY) == 0
1583                && HAVE_SECTION (hold_data, ".data"))
1584         place = &hold_data;
1585       else if ((s->flags & SEC_CODE) == 0
1586                && (s->flags & SEC_READONLY) != 0
1587                && HAVE_SECTION (hold_rdata, ".rdata"))
1588         place = &hold_rdata;
1589       else if ((s->flags & SEC_READONLY) != 0
1590                && HAVE_SECTION (hold_text, ".text"))
1591         place = &hold_text;
1592
1593 #undef HAVE_SECTION
1594
1595       /* Choose a unique name for the section.  This will be needed if
1596          the same section name appears in the input file with
1597          different loadable or allocatable characteristics.  */
1598       outsecname = xstrdup (hold_section_name);
1599       if (bfd_get_section_by_name (output_bfd, outsecname) != NULL)
1600         {
1601           unsigned int len;
1602           char *newname;
1603           unsigned int i;
1604
1605           len = strlen (outsecname);
1606           newname = xmalloc (len + 5);
1607           strcpy (newname, outsecname);
1608           i = 0;
1609           do
1610             {
1611               sprintf (newname + len, "%d", i);
1612               ++i;
1613             }
1614           while (bfd_get_section_by_name (output_bfd, newname) != NULL);
1615
1616           free (outsecname);
1617           outsecname = newname;
1618         }
1619
1620       /* Start building a list of statements for this section.  */
1621       old = stat_ptr;
1622       stat_ptr = &add;
1623       lang_list_init (stat_ptr);
1624
1625       if (config.build_constructors)
1626         {
1627           /* If the name of the section is representable in C, then create
1628              symbols to mark the start and the end of the section.  */
1629           for (ps = outsecname; *ps != '\0'; ps++)
1630             if (! isalnum ((unsigned char) *ps) && *ps != '_')
1631               break;
1632           if (*ps == '\0')
1633             {
1634               char *symname;
1635               etree_type *e_align;
1636
1637               symname = (char *) xmalloc (ps - outsecname + sizeof "___start_");
1638               sprintf (symname, "___start_%s", outsecname);
1639               e_align = exp_unop (ALIGN_K,
1640                                   exp_intop ((bfd_vma) 1 << s->alignment_power));
1641               lang_add_assignment (exp_assop ('=', symname, e_align));
1642             }
1643         }
1644
1645       if (link_info.relocateable || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)
1646         address = exp_intop ((bfd_vma) 0);
1647       else
1648         {
1649           /* All sections in an executable must be aligned to a page
1650              boundary.  */
1651           address = exp_unop (ALIGN_K,
1652                               exp_nameop (NAME, "__section_alignment__"));
1653         }
1654
1655       os = lang_enter_output_section_statement (outsecname, address, 0,
1656                                                 (bfd_vma) 0,
1657                                                 (etree_type *) NULL,
1658                                                 (etree_type *) NULL,
1659                                                 (etree_type *) NULL);
1660
1661       lang_add_section (&add_child, s, os, file);
1662
1663       lang_leave_output_section_statement
1664         ((bfd_vma) 0, "*default*",
1665          (struct lang_output_section_phdr_list *) NULL, NULL);
1666
1667       if (config.build_constructors && *ps == '\0')
1668         {
1669           char *symname;
1670
1671           /* lang_leave_ouput_section_statement resets stat_ptr.
1672              Put stat_ptr back where we want it.  */
1673           if (place != NULL)
1674             stat_ptr = &add;
1675
1676           symname = (char *) xmalloc (ps - outsecname + sizeof "___stop_");
1677           sprintf (symname, "___stop_%s", outsecname);
1678           lang_add_assignment (exp_assop ('=', symname,
1679                                           exp_nameop (NAME, ".")));
1680         }
1681
1682       stat_ptr = old;
1683
1684       if (place != NULL && os->bfd_section != NULL)
1685         {
1686           asection *snew, **pps;
1687
1688           snew = os->bfd_section;
1689
1690           /* Shuffle the bfd section list to make the output file look
1691              neater.  This is really only cosmetic.  */
1692           if (place->section == NULL)
1693             {
1694               asection *bfd_section = place->os->bfd_section;
1695
1696               /* If the output statement hasn't been used to place
1697                  any input sections (and thus doesn't have an output
1698                  bfd_section), look for the closest prior output statement
1699                  having an output section.  */
1700               if (bfd_section == NULL)
1701                 bfd_section = output_prev_sec_find (place->os);
1702
1703               if (bfd_section != NULL && bfd_section != snew)
1704                 place->section = &bfd_section->next;
1705             }
1706
1707           if (place->section != NULL)
1708             {
1709               /* Unlink the section.  */
1710               for (pps = &output_bfd->sections;
1711                    *pps != snew;
1712                    pps = &(*pps)->next)
1713                 ;
1714               bfd_section_list_remove (output_bfd, pps);
1715
1716               /* Now tack it on to the "place->os" section list.  */
1717               bfd_section_list_insert (output_bfd, place->section, snew);
1718             }
1719
1720           /* Save the end of this list.  Further ophans of this type will
1721              follow the one we've just added.  */
1722           place->section = &snew->next;
1723
1724           /* The following is non-cosmetic.  We try to put the output
1725              statements in some sort of reasonable order here, because
1726              they determine the final load addresses of the orphan
1727              sections.  In addition, placing output statements in the
1728              wrong order may require extra segments.  For instance,
1729              given a typical situation of all read-only sections placed
1730              in one segment and following that a segment containing all
1731              the read-write sections, we wouldn't want to place an orphan
1732              read/write section before or amongst the read-only ones.  */
1733           if (add.head != NULL)
1734             {
1735               if (place->stmt == NULL)
1736                 {
1737                   /* Put the new statement list right at the head.  */
1738                   *add.tail = place->os->header.next;
1739                   place->os->header.next = add.head;
1740                 }
1741               else
1742                 {
1743                   /* Put it after the last orphan statement we added.  */
1744                   *add.tail = *place->stmt;
1745                   *place->stmt = add.head;
1746                 }
1747
1748               /* Fix the global list pointer if we happened to tack our
1749                  new list at the tail.  */
1750               if (*old->tail == add.head)
1751                 old->tail = add.tail;
1752
1753               /* Save the end of this list.  */
1754               place->stmt = add.tail;
1755             }
1756         }
1757     }
1758
1759   {
1760     lang_statement_union_type **pl = &os->children.head;
1761
1762     if (dollar != NULL)
1763       {
1764         bfd_boolean found_dollar;
1765
1766         /* The section name has a '$'.  Sort it with the other '$'
1767            sections.  */
1768         found_dollar = FALSE;
1769         for ( ; *pl != NULL; pl = &(*pl)->header.next)
1770           {
1771             lang_input_section_type *ls;
1772             const char *lname;
1773
1774             if ((*pl)->header.type != lang_input_section_enum)
1775               continue;
1776
1777             ls = &(*pl)->input_section;
1778
1779             lname = bfd_get_section_name (ls->ifile->the_bfd, ls->section);
1780             if (strchr (lname, '$') == NULL)
1781               {
1782                 if (found_dollar)
1783                   break;
1784               }
1785             else
1786               {
1787                 found_dollar = TRUE;
1788                 if (strcmp (secname, lname) < 0)
1789                   break;
1790               }
1791           }
1792       }
1793
1794     if (add_child.head != NULL)
1795       {
1796         add_child.head->header.next = *pl;
1797         *pl = add_child.head;
1798       }
1799   }
1800
1801   free (hold_section_name);
1802
1803   return TRUE;
1804 }
1805
1806 static bfd_boolean
1807 gld_${EMULATION_NAME}_open_dynamic_archive (arch, search, entry)
1808      const char * arch ATTRIBUTE_UNUSED;
1809      search_dirs_type * search;
1810      lang_input_statement_type * entry;
1811 {
1812   const char * filename;
1813   char * string;
1814
1815   if (! entry->is_archive)
1816     return FALSE;
1817
1818   filename = entry->filename;
1819
1820   string = (char *) xmalloc (strlen (search->name)
1821                              + strlen (filename)
1822                              + sizeof "/lib.a.dll"
1823 #ifdef DLL_SUPPORT
1824                              + (pe_dll_search_prefix ? strlen (pe_dll_search_prefix) : 0)
1825 #endif
1826                              + 1);
1827
1828   /* Try "libfoo.dll.a" first (preferred explicit import library for dll's.  */
1829   sprintf (string, "%s/lib%s.dll.a", search->name, filename);
1830
1831   if (! ldfile_try_open_bfd (string, entry))
1832     {
1833       /* Try "foo.dll.a" next (alternate explicit import library for dll's.  */
1834       sprintf (string, "%s/%s.dll.a", search->name, filename);
1835       if (! ldfile_try_open_bfd (string, entry))
1836         {
1837           /* Try libfoo.a next. Normally, this would be interpreted as a static
1838              library, but it *could* be an import library. For backwards compatibility,
1839              libfoo.a needs to ==precede== libfoo.dll and foo.dll in the search,
1840              or sometimes errors occur when building legacy packages.
1841
1842              Putting libfoo.a here means that in a failure case (i.e. the library
1843              -lfoo is not found) we will search for libfoo.a twice before
1844              giving up -- once here, and once when searching for a "static" lib.
1845              for a "static" lib.  */
1846           /* Try "libfoo.a" (import lib, or static lib, but must
1847              take precedence over dll's) */
1848           sprintf (string, "%s/lib%s.a", search->name, filename);
1849           if (! ldfile_try_open_bfd (string, entry))
1850             {
1851 #ifdef DLL_SUPPORT
1852               if (pe_dll_search_prefix)
1853                 {
1854                   /* Try "<prefix>foo.dll" (preferred dll name, if specified) */
1855                   sprintf (string, "%s/%s%s.dll", search->name, pe_dll_search_prefix, filename);
1856                   if (! ldfile_try_open_bfd (string, entry))
1857                     {
1858                       /* Try "libfoo.dll" (default preferred dll name) */
1859                       sprintf (string, "%s/lib%s.dll", search->name, filename);
1860                       if (! ldfile_try_open_bfd (string, entry))
1861                         {
1862                           /* Finally, try "foo.dll" (alternate dll name) */
1863                           sprintf (string, "%s/%s.dll", search->name, filename);
1864                           if (! ldfile_try_open_bfd (string, entry))
1865                             {
1866                               free (string);
1867                               return FALSE;
1868                             }
1869                         }
1870                     }
1871                 }
1872               else /* pe_dll_search_prefix not specified.  */
1873 #endif
1874                 {
1875                   /* Try "libfoo.dll" (preferred dll name).  */
1876                   sprintf (string, "%s/lib%s.dll", search->name, filename);
1877                   if (! ldfile_try_open_bfd (string, entry))
1878                     {
1879                       /* Finally, try "foo.dll" (alternate dll name).  */
1880                       sprintf (string, "%s/%s.dll", search->name, filename);
1881                       if (! ldfile_try_open_bfd (string, entry))
1882                         {
1883                           free (string);
1884                           return FALSE;
1885                         }
1886                     }
1887                 }
1888             }
1889         }
1890     }
1891
1892   entry->filename = string;
1893
1894   return TRUE;
1895 }
1896
1897 static int
1898 gld_${EMULATION_NAME}_find_potential_libraries (name, entry)
1899      char * name;
1900      lang_input_statement_type * entry;
1901 {
1902   return ldfile_open_file_search (name, entry, "", ".lib");
1903 }
1904 \f
1905 static char *
1906 gld_${EMULATION_NAME}_get_script(isfile)
1907      int *isfile;
1908 EOF
1909 # Scripts compiled in.
1910 # sed commands to quote an ld script as a C string.
1911 sc="-f stringify.sed"
1912
1913 cat >>e${EMULATION_NAME}.c <<EOF
1914 {
1915   *isfile = 0;
1916
1917   if (link_info.relocateable && config.build_constructors)
1918     return
1919 EOF
1920 sed $sc ldscripts/${EMULATION_NAME}.xu                 >> e${EMULATION_NAME}.c
1921 echo '  ; else if (link_info.relocateable) return'     >> e${EMULATION_NAME}.c
1922 sed $sc ldscripts/${EMULATION_NAME}.xr                 >> e${EMULATION_NAME}.c
1923 echo '  ; else if (!config.text_read_only) return'     >> e${EMULATION_NAME}.c
1924 sed $sc ldscripts/${EMULATION_NAME}.xbn                >> e${EMULATION_NAME}.c
1925 echo '  ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
1926 sed $sc ldscripts/${EMULATION_NAME}.xn                 >> e${EMULATION_NAME}.c
1927 echo '  ; else return'                                 >> e${EMULATION_NAME}.c
1928 sed $sc ldscripts/${EMULATION_NAME}.x                  >> e${EMULATION_NAME}.c
1929 echo '; }'                                             >> e${EMULATION_NAME}.c
1930
1931 cat >>e${EMULATION_NAME}.c <<EOF
1932
1933
1934 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1935 {
1936   gld_${EMULATION_NAME}_before_parse,
1937   syslib_default,
1938   hll_default,
1939   gld_${EMULATION_NAME}_after_parse,
1940   gld_${EMULATION_NAME}_after_open,
1941   after_allocation_default,
1942   set_output_arch_default,
1943   ldemul_default_target,
1944   gld_${EMULATION_NAME}_before_allocation,
1945   gld_${EMULATION_NAME}_get_script,
1946   "${EMULATION_NAME}",
1947   "${OUTPUT_FORMAT}",
1948   gld_${EMULATION_NAME}_finish, /* finish */
1949   NULL, /* create output section statements */
1950   gld_${EMULATION_NAME}_open_dynamic_archive,
1951   gld_${EMULATION_NAME}_place_orphan,
1952   gld_${EMULATION_NAME}_set_symbols,
1953   gld_${EMULATION_NAME}_parse_args,
1954   gld_${EMULATION_NAME}_unrecognized_file,
1955   gld_${EMULATION_NAME}_list_options,
1956   gld_${EMULATION_NAME}_recognized_file,
1957   gld_${EMULATION_NAME}_find_potential_libraries,
1958   NULL  /* new_vers_pattern */
1959 };
1960 EOF