ld/emultempl/pe.em

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