ld/emultempl/pe.em

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