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