ld/emultempl/pep.em

   1 # This shell script emits a C file. -*- C -*-
   2 # It does some substitutions.
   3 test -z "${ENTRY}" && ENTRY="_mainCRTStartup"
   4 if [ -z "$MACHINE" ]; then
   5   OUTPUT_ARCH=${ARCH}
   6 else
   7   OUTPUT_ARCH=${ARCH}:${MACHINE}
   8 fi
   9 rm -f e${EMULATION_NAME}.c
  10 (echo;echo;echo;echo;echo)>e${EMULATION_NAME}.c # there, now line numbers match ;-)
  11 fragment <<EOF
  12 /* Copyright 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
  13    Written by Kai Tietz, OneVision Software GmbH&CoKg.
  14
  15    This file is part of the GNU Binutils.
  16
  17    This program is free software; you can redistribute it and/or modify
  18    it under the terms of the GNU General Public License as published by
  19    the Free Software Foundation; either version 3 of the License, or
  20    (at your option) any later version.
  21
  22    This program is distributed in the hope that it will be useful,
  23    but WITHOUT ANY WARRANTY; without even the implied warranty of
  24    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  25    GNU General Public License for more details.
  26
  27    You should have received a copy of the GNU General Public License
  28    along with this program; if not, write to the Free Software
  29    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  30    MA 02110-1301, USA.  */
  31
  32
  33 /* For WINDOWS_XP64 and higher */
  34 /* Based on pe.em, but modified for 64 bit support.  */
  35
  36 #define TARGET_IS_${EMULATION_NAME}
  37
  38 #define COFF_IMAGE_WITH_PE
  39 #define COFF_WITH_PE
  40 #define COFF_WITH_pex64
  41
  42 #include "sysdep.h"
  43 #include "bfd.h"
  44 #include "bfdlink.h"
  45 #include "getopt.h"
  46 #include "libiberty.h"
  47 #include "ld.h"
  48 #include "ldmain.h"
  49 #include "ldexp.h"
  50 #include "ldlang.h"
  51 #include "ldfile.h"
  52 #include "ldemul.h"
  53 #include <ldgram.h>
  54 #include "ldlex.h"
  55 #include "ldmisc.h"
  56 #include "ldctor.h"
  57 #include "coff/internal.h"
  58
  59 /* FIXME: See bfd/peXXigen.c for why we include an architecture specific
  60    header in generic PE code.  */
  61 #include "coff/x86_64.h"
  62 #include "coff/pe.h"
  63
  64 /* FIXME: This is a BFD internal header file, and we should not be
  65    using it here.  */
  66 #include "../bfd/libcoff.h"
  67
  68 #undef  AOUTSZ
  69 #define AOUTSZ          PEPAOUTSZ
  70 #define PEAOUTHDR       PEPAOUTHDR
  71
  72 #include "deffile.h"
  73 #include "pep-dll.h"
  74 #include "safe-ctype.h"
  75
  76 /* Permit the emulation parameters to override the default section
  77    alignment by setting OVERRIDE_SECTION_ALIGNMENT.  FIXME: This makes
  78    it seem that include/coff/internal.h should not define
  79    PE_DEF_SECTION_ALIGNMENT.  */
  80 #if PE_DEF_SECTION_ALIGNMENT != ${OVERRIDE_SECTION_ALIGNMENT:-PE_DEF_SECTION_ALIGNMENT}
  81 #undef  PE_DEF_SECTION_ALIGNMENT
  82 #define PE_DEF_SECTION_ALIGNMENT ${OVERRIDE_SECTION_ALIGNMENT}
  83 #endif
  84
  85 #ifdef TARGET_IS_i386pep
  86 #define DLL_SUPPORT
  87 #endif
  88
  89 #if defined(TARGET_IS_i386pep) || ! defined(DLL_SUPPORT)
  90 #define PE_DEF_SUBSYSTEM                3
  91 #else
  92 #undef  NT_EXE_IMAGE_BASE
  93 #define NT_EXE_IMAGE_BASE               0x00010000
  94 #undef  PE_DEF_SECTION_ALIGNMENT
  95 #define PE_DEF_SUBSYSTEM                2
  96 #undef  PE_DEF_FILE_ALIGNMENT
  97 #define PE_DEF_FILE_ALIGNMENT           0x00000200
  98 #define PE_DEF_SECTION_ALIGNMENT        0x00000400
  99 #endif
 100
 101
 102 static struct internal_extra_pe_aouthdr pep;
 103 static int dll;
 104 static flagword real_flags = IMAGE_FILE_LARGE_ADDRESS_AWARE;
 105 static int support_old_code = 0;
 106 static lang_assignment_statement_type *image_base_statement = 0;
 107 static unsigned short pe_dll_characteristics = 0;
 108
 109 #ifdef DLL_SUPPORT
 110 static int    pep_enable_stdcall_fixup = 1; /* 0=disable 1=enable (default).  */
 111 static char * pep_out_def_filename = NULL;
 112 static char * pep_implib_filename = NULL;
 113 static int    pep_enable_auto_image_base = 0;
 114 static char * pep_dll_search_prefix = NULL;
 115 #endif
 116
 117 extern const char *output_filename;
 118
 119 static void
 120 gld_${EMULATION_NAME}_before_parse (void)
 121 {
 122   ldfile_set_output_arch ("${OUTPUT_ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`);
 123   output_filename = "${EXECUTABLE_NAME:-a.exe}";
 124 #ifdef DLL_SUPPORT
 125   config.dynamic_link = TRUE;
 126   config.has_shared = 1;
 127   link_info.pei386_auto_import = -1;
 128   link_info.pei386_runtime_pseudo_reloc = 2; /* Use by default version 2.  */
 129
 130 #if (PE_DEF_SUBSYSTEM == 9) || (PE_DEF_SUBSYSTEM == 2)
 131   lang_default_entry ("_WinMainCRTStartup");
 132 #else
 133   lang_default_entry ("${ENTRY}");
 134 #endif
 135 #endif
 136 }
 137 \f
 138 /* PE format extra command line options.  */
 139
 140 /* Used for setting flags in the PE header.  */
 141 enum options
 142 {
 143   OPTION_BASE_FILE = 300 + 1,
 144   OPTION_DLL,
 145   OPTION_FILE_ALIGNMENT,
 146   OPTION_IMAGE_BASE,
 147   OPTION_MAJOR_IMAGE_VERSION,
 148   OPTION_MAJOR_OS_VERSION,
 149   OPTION_MAJOR_SUBSYSTEM_VERSION,
 150   OPTION_MINOR_IMAGE_VERSION,
 151   OPTION_MINOR_OS_VERSION,
 152   OPTION_MINOR_SUBSYSTEM_VERSION,
 153   OPTION_SECTION_ALIGNMENT,
 154   OPTION_STACK,
 155   OPTION_SUBSYSTEM,
 156   OPTION_HEAP,
 157   OPTION_SUPPORT_OLD_CODE,
 158   OPTION_OUT_DEF,
 159   OPTION_EXPORT_ALL,
 160   OPTION_EXCLUDE_SYMBOLS,
 161   OPTION_KILL_ATS,
 162   OPTION_STDCALL_ALIASES,
 163   OPTION_ENABLE_STDCALL_FIXUP,
 164   OPTION_DISABLE_STDCALL_FIXUP,
 165   OPTION_IMPLIB_FILENAME,
 166   OPTION_WARN_DUPLICATE_EXPORTS,
 167   OPTION_IMP_COMPAT,
 168   OPTION_ENABLE_AUTO_IMAGE_BASE,
 169   OPTION_DISABLE_AUTO_IMAGE_BASE,
 170   OPTION_DLL_SEARCH_PREFIX,
 171   OPTION_NO_DEFAULT_EXCLUDES,
 172   OPTION_DLL_ENABLE_AUTO_IMPORT,
 173   OPTION_DLL_DISABLE_AUTO_IMPORT,
 174   OPTION_ENABLE_EXTRA_PE_DEBUG,
 175   OPTION_EXCLUDE_LIBS,
 176   OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC,
 177   OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC,
 178   OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V1,
 179   OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V2,
 180   OPTION_EXCLUDE_MODULES_FOR_IMPLIB,
 181   OPTION_USE_NUL_PREFIXED_IMPORT_TABLES,
 182   OPTION_ENABLE_LONG_SECTION_NAMES,
 183   OPTION_DISABLE_LONG_SECTION_NAMES,
 184   OPTION_DYNAMIC_BASE,
 185   OPTION_FORCE_INTEGRITY,
 186   OPTION_NX_COMPAT,
 187   OPTION_NO_ISOLATION,
 188   OPTION_NO_SEH,
 189   OPTION_NO_BIND,
 190   OPTION_WDM_DRIVER,
 191   OPTION_TERMINAL_SERVER_AWARE
 192 };
 193
 194 static void
 195 gld${EMULATION_NAME}_add_options
 196   (int ns ATTRIBUTE_UNUSED,
 197    char **shortopts ATTRIBUTE_UNUSED,
 198    int nl,
 199    struct option **longopts,
 200    int nrl ATTRIBUTE_UNUSED,
 201    struct option **really_longopts ATTRIBUTE_UNUSED)
 202 {
 203   static const struct option xtra_long[] =
 204   {
 205     /* PE options */
 206     {"base-file", required_argument, NULL, OPTION_BASE_FILE},
 207     {"dll", no_argument, NULL, OPTION_DLL},
 208     {"file-alignment", required_argument, NULL, OPTION_FILE_ALIGNMENT},
 209     {"heap", required_argument, NULL, OPTION_HEAP},
 210     {"image-base", required_argument, NULL, OPTION_IMAGE_BASE},
 211     {"major-image-version", required_argument, NULL, OPTION_MAJOR_IMAGE_VERSION},
 212     {"major-os-version", required_argument, NULL, OPTION_MAJOR_OS_VERSION},
 213     {"major-subsystem-version", required_argument, NULL, OPTION_MAJOR_SUBSYSTEM_VERSION},
 214     {"minor-image-version", required_argument, NULL, OPTION_MINOR_IMAGE_VERSION},
 215     {"minor-os-version", required_argument, NULL, OPTION_MINOR_OS_VERSION},
 216     {"minor-subsystem-version", required_argument, NULL, OPTION_MINOR_SUBSYSTEM_VERSION},
 217     {"section-alignment", required_argument, NULL, OPTION_SECTION_ALIGNMENT},
 218     {"stack", required_argument, NULL, OPTION_STACK},
 219     {"subsystem", required_argument, NULL, OPTION_SUBSYSTEM},
 220     {"support-old-code", no_argument, NULL, OPTION_SUPPORT_OLD_CODE},
 221     {"use-nul-prefixed-import-tables", no_argument, NULL,
 222      OPTION_USE_NUL_PREFIXED_IMPORT_TABLES},
 223 #ifdef DLL_SUPPORT
 224     /* getopt allows abbreviations, so we do this to stop it
 225        from treating -o as an abbreviation for this option.  */
 226     {"output-def", required_argument, NULL, OPTION_OUT_DEF},
 227     {"output-def", required_argument, NULL, OPTION_OUT_DEF},
 228     {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL},
 229     {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMBOLS},
 230     {"exclude-libs", required_argument, NULL, OPTION_EXCLUDE_LIBS},
 231     {"exclude-modules-for-implib", required_argument, NULL, OPTION_EXCLUDE_MODULES_FOR_IMPLIB},
 232     {"kill-at", no_argument, NULL, OPTION_KILL_ATS},
 233     {"add-stdcall-alias", no_argument, NULL, OPTION_STDCALL_ALIASES},
 234     {"enable-stdcall-fixup", no_argument, NULL, OPTION_ENABLE_STDCALL_FIXUP},
 235     {"disable-stdcall-fixup", no_argument, NULL, OPTION_DISABLE_STDCALL_FIXUP},
 236     {"out-implib", required_argument, NULL, OPTION_IMPLIB_FILENAME},
 237     {"warn-duplicate-exports", no_argument, NULL, OPTION_WARN_DUPLICATE_EXPORTS},
 238     /* getopt() allows abbreviations, so we do this to stop it from
 239        treating -c as an abbreviation for these --compat-implib.  */
 240     {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT},
 241     {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT},
 242     {"enable-auto-image-base", no_argument, NULL, OPTION_ENABLE_AUTO_IMAGE_BASE},
 243     {"disable-auto-image-base", no_argument, NULL, OPTION_DISABLE_AUTO_IMAGE_BASE},
 244     {"dll-search-prefix", required_argument, NULL, OPTION_DLL_SEARCH_PREFIX},
 245     {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES},
 246     {"enable-auto-import", no_argument, NULL, OPTION_DLL_ENABLE_AUTO_IMPORT},
 247     {"disable-auto-import", no_argument, NULL, OPTION_DLL_DISABLE_AUTO_IMPORT},
 248     {"enable-extra-pep-debug", no_argument, NULL, OPTION_ENABLE_EXTRA_PE_DEBUG},
 249     {"enable-runtime-pseudo-reloc", no_argument, NULL, OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC},
 250     {"disable-runtime-pseudo-reloc", no_argument, NULL, OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC},
 251     {"enable-runtime-pseudo-reloc-v1", no_argument, NULL, OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V1},
 252     {"enable-runtime-pseudo-reloc-v2", no_argument, NULL, OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V2},
 253 #endif
 254     {"enable-long-section-names", no_argument, NULL, OPTION_ENABLE_LONG_SECTION_NAMES},
 255     {"disable-long-section-names", no_argument, NULL, OPTION_DISABLE_LONG_SECTION_NAMES},
 256     {"dynamicbase",no_argument, NULL, OPTION_DYNAMIC_BASE},
 257     {"forceinteg", no_argument, NULL, OPTION_FORCE_INTEGRITY},
 258     {"nxcompat", no_argument, NULL, OPTION_NX_COMPAT},
 259     {"no-isolation", no_argument, NULL, OPTION_NO_ISOLATION},
 260     {"no-seh", no_argument, NULL, OPTION_NO_SEH},
 261     {"no-bind", no_argument, NULL, OPTION_NO_BIND},
 262     {"wdmdriver", no_argument, NULL, OPTION_WDM_DRIVER},
 263     {"tsaware", no_argument, NULL, OPTION_TERMINAL_SERVER_AWARE},
 264     {NULL, no_argument, NULL, 0}
 265   };
 266
 267   *longopts
 268     = xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long));
 269   memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long));
 270 }
 271
 272 /* PE/WIN32; added routines to get the subsystem type, heap and/or stack
 273    parameters which may be input from the command line.  */
 274
 275 typedef struct
 276 {
 277   void *ptr;
 278   int size;
 279   bfd_vma value;
 280   char *symbol;
 281   int inited;
 282 } definfo;
 283
 284 #define D(field,symbol,def)  {&pep.field,sizeof(pep.field), def, symbol,0}
 285
 286 static definfo init[] =
 287 {
 288   /* imagebase must be first */
 289 #define IMAGEBASEOFF 0
 290   D(ImageBase,"__image_base__", NT_EXE_IMAGE_BASE),
 291 #define DLLOFF 1
 292   {&dll, sizeof(dll), 0, "__dll__", 0},
 293 #define MSIMAGEBASEOFF  2
 294   D(ImageBase,"___ImageBase", NT_EXE_IMAGE_BASE),
 295   D(SectionAlignment,"__section_alignment__", PE_DEF_SECTION_ALIGNMENT),
 296   D(FileAlignment,"__file_alignment__", PE_DEF_FILE_ALIGNMENT),
 297   D(MajorOperatingSystemVersion,"__major_os_version__", 4),
 298   D(MinorOperatingSystemVersion,"__minor_os_version__", 0),
 299   D(MajorImageVersion,"__major_image_version__", 0),
 300   D(MinorImageVersion,"__minor_image_version__", 0),
 301   D(MajorSubsystemVersion,"__major_subsystem_version__", 5),
 302   D(MinorSubsystemVersion,"__minor_subsystem_version__", 2),
 303   D(Subsystem,"__subsystem__", ${SUBSYSTEM}),
 304   D(SizeOfStackReserve,"__size_of_stack_reserve__", 0x200000),
 305   D(SizeOfStackCommit,"__size_of_stack_commit__", 0x1000),
 306   D(SizeOfHeapReserve,"__size_of_heap_reserve__", 0x100000),
 307   D(SizeOfHeapCommit,"__size_of_heap_commit__", 0x1000),
 308   D(LoaderFlags,"__loader_flags__", 0x0),
 309   D(DllCharacteristics, "__dll_characteristics__", 0x0),
 310   { NULL, 0, 0, NULL, 0 }
 311 };
 312
 313
 314 static void
 315 gld_${EMULATION_NAME}_list_options (FILE *file)
 316 {
 317   fprintf (file, _("  --base_file <basefile>             Generate a base file for relocatable DLLs\n"));
 318   fprintf (file, _("  --dll                              Set image base to the default for DLLs\n"));
 319   fprintf (file, _("  --file-alignment <size>            Set file alignment\n"));
 320   fprintf (file, _("  --heap <size>                      Set initial size of the heap\n"));
 321   fprintf (file, _("  --image-base <address>             Set start address of the executable\n"));
 322   fprintf (file, _("  --major-image-version <number>     Set version number of the executable\n"));
 323   fprintf (file, _("  --major-os-version <number>        Set minimum required OS version\n"));
 324   fprintf (file, _("  --major-subsystem-version <number> Set minimum required OS subsystem version\n"));
 325   fprintf (file, _("  --minor-image-version <number>     Set revision number of the executable\n"));
 326   fprintf (file, _("  --minor-os-version <number>        Set minimum required OS revision\n"));
 327   fprintf (file, _("  --minor-subsystem-version <number> Set minimum required OS subsystem revision\n"));
 328   fprintf (file, _("  --section-alignment <size>         Set section alignment\n"));
 329   fprintf (file, _("  --stack <size>                     Set size of the initial stack\n"));
 330   fprintf (file, _("  --subsystem <name>[:<version>]     Set required OS subsystem [& version]\n"));
 331   fprintf (file, _("  --support-old-code                 Support interworking with old code\n"));
 332 #ifdef DLL_SUPPORT
 333   fprintf (file, _("  --add-stdcall-alias                Export symbols with and without @nn\n"));
 334   fprintf (file, _("  --disable-stdcall-fixup            Don't link _sym to _sym@nn\n"));
 335   fprintf (file, _("  --enable-stdcall-fixup             Link _sym to _sym@nn without warnings\n"));
 336   fprintf (file, _("  --exclude-symbols sym,sym,...      Exclude symbols from automatic export\n"));
 337   fprintf (file, _("  --exclude-libs lib,lib,...         Exclude libraries from automatic export\n"));
 338   fprintf (file, _("  --exclude-modules-for-implib mod,mod,...\n"));
 339   fprintf (file, _("                                     Exclude objects, archive members from auto\n"));
 340   fprintf (file, _("                                     export, place into import library instead.\n"));
 341   fprintf (file, _("  --export-all-symbols               Automatically export all globals to DLL\n"));
 342   fprintf (file, _("  --kill-at                          Remove @nn from exported symbols\n"));
 343   fprintf (file, _("  --out-implib <file>                Generate import library\n"));
 344   fprintf (file, _("  --output-def <file>                Generate a .DEF file for the built DLL\n"));
 345   fprintf (file, _("  --warn-duplicate-exports           Warn about duplicate exports.\n"));
 346   fprintf (file, _("  --compat-implib                    Create backward compatible import libs;\n\
 347                                        create __imp_<SYMBOL> as well.\n"));
 348   fprintf (file, _("  --enable-auto-image-base           Automatically choose image base for DLLs\n\
 349                                        unless user specifies one\n"));
 350   fprintf (file, _("  --disable-auto-image-base          Do not auto-choose image base. (default)\n"));
 351   fprintf (file, _("  --dll-search-prefix=<string>       When linking dynamically to a dll without\n\
 352                                        an importlib, use <string><basename>.dll\n\
 353                                        in preference to lib<basename>.dll \n"));
 354   fprintf (file, _("  --enable-auto-import               Do sophistcated linking of _sym to\n\
 355                                        __imp_sym for DATA references\n"));
 356   fprintf (file, _("  --disable-auto-import              Do not auto-import DATA items from DLLs\n"));
 357   fprintf (file, _("  --enable-runtime-pseudo-reloc      Work around auto-import limitations by\n\
 358                                        adding pseudo-relocations resolved at\n\
 359                                        runtime.\n"));
 360   fprintf (file, _("  --disable-runtime-pseudo-reloc     Do not add runtime pseudo-relocations for\n\
 361                                        auto-imported DATA.\n"));
 362   fprintf (file, _("  --enable-extra-pep-debug            Enable verbose debug output when building\n\
 363                                        or linking to DLLs (esp. auto-import)\n"));
 364   fprintf (file, _("  --enable-long-section-names        Use long COFF section names even in\n\
 365                                        executable image files\n"));
 366   fprintf (file, _("  --disable-long-section-names       Never use long COFF section names, even\n\
 367                                        in object files\n"));
 368   fprintf (file, _("  --dynamicbase                      Image base address may be relocated using\n\
 369                                        address space layout randomization (ASLR)\n"));
 370   fprintf (file, _("  --forceinteg               Code integrity checks are enforced\n"));
 371   fprintf (file, _("  --nxcompat                 Image is compatible with data execution prevention\n"));
 372   fprintf (file, _("  --no-isolation             Image understands isolation but do not isolate the image\n"));
 373   fprintf (file, _("  --no-seh                   Image does not use SEH. No SE handler may\n\
 374                                        be called in this image\n"));
 375   fprintf (file, _("  --no-bind                  Do not bind this image\n"));
 376   fprintf (file, _("  --wdmdriver                Driver uses the WDM model\n"));
 377   fprintf (file, _("  --tsaware                  Image is Terminal Server aware\n"));
 378 #endif
 379 }
 380
 381
 382 static void
 383 set_pep_name (char *name, bfd_vma val)
 384 {
 385   int i;
 386
 387   /* Find the name and set it.  */
 388   for (i = 0; init[i].ptr; i++)
 389     {
 390       if (strcmp (name, init[i].symbol) == 0)
 391         {
 392           init[i].value = val;
 393           init[i].inited = 1;
 394           if (strcmp (name,"__image_base__") == 0)
 395             set_pep_name ("___ImageBase", val);
 396           return;
 397         }
 398     }
 399   abort ();
 400 }
 401
 402
 403 static void
 404 set_pep_subsystem (void)
 405 {
 406   const char *sver;
 407   const char *entry;
 408   const char *initial_symbol_char;
 409   char *end;
 410   int len;
 411   int i;
 412   int subsystem;
 413   unsigned long temp_subsystem;
 414   static const struct
 415     {
 416       const char *name;
 417       const int value;
 418       const char *entry;
 419     }
 420   v[] =
 421     {
 422       { "native",  1, "NtProcessStartup" },
 423       { "windows", 2, "WinMainCRTStartup" },
 424       { "console", 3, "mainCRTStartup" },
 425       { "posix",   7, "__PosixProcessStartup"},
 426       { "wince",   9, "_WinMainCRTStartup" },
 427       { "xbox",   14, "mainCRTStartup" },
 428       { NULL, 0, NULL }
 429     };
 430   /* Entry point name for arbitrary subsystem numbers.  */
 431   static const char default_entry[] = "mainCRTStartup";
 432
 433   /* Check for the presence of a version number.  */
 434   sver = strchr (optarg, ':');
 435   if (sver == NULL)
 436     len = strlen (optarg);
 437   else
 438     {
 439       len = sver - optarg;
 440       set_pep_name ("__major_subsystem_version__",
 441                     strtoul (sver + 1, &end, 0));
 442       if (*end == '.')
 443         set_pep_name ("__minor_subsystem_version__",
 444                       strtoul (end + 1, &end, 0));
 445       if (*end != '\0')
 446         einfo (_("%P: warning: bad version number in -subsystem option\n"));
 447     }
 448
 449   /* Check for numeric subsystem.  */
 450   temp_subsystem = strtoul (optarg, & end, 0);
 451   if ((*end == ':' || *end == '\0') && (temp_subsystem < 65536))
 452     {
 453       /* Search list for a numeric match to use its entry point.  */
 454       for (i = 0; v[i].name; i++)
 455         if (v[i].value == (int) temp_subsystem)
 456           break;
 457
 458       /* If no match, use the default.  */
 459       if (v[i].name != NULL)
 460         entry = v[i].entry;
 461       else
 462         entry = default_entry;
 463
 464       /* Use this subsystem.  */
 465       subsystem = (int) temp_subsystem;
 466     }
 467   else
 468     {
 469       /* Search for subsystem by name.  */
 470       for (i = 0; v[i].name; i++)
 471         if (strncmp (optarg, v[i].name, len) == 0
 472             && v[i].name[len] == '\0')
 473           break;
 474
 475       if (v[i].name == NULL)
 476         {
 477           einfo (_("%P%F: invalid subsystem type %s\n"), optarg);
 478           return;
 479         }
 480
 481       entry = v[i].entry;
 482       subsystem = v[i].value;
 483     }
 484
 485   set_pep_name ("__subsystem__", subsystem);
 486
 487   initial_symbol_char = ${INITIAL_SYMBOL_CHAR};
 488   if (*initial_symbol_char != '\0')
 489     {
 490       char *alc_entry;
 491
 492       /* lang_default_entry expects its argument to be permanently
 493          allocated, so we don't free this string.  */
 494       alc_entry = xmalloc (strlen (initial_symbol_char)
 495                            + strlen (entry)
 496                            + 1);
 497       strcpy (alc_entry, initial_symbol_char);
 498       strcat (alc_entry, entry);
 499       entry = alc_entry;
 500     }
 501
 502   lang_default_entry (entry);
 503
 504   return;
 505 }
 506
 507
 508 static void
 509 set_pep_value (char *name)
 510 {
 511   char *end;
 512
 513   set_pep_name (name,  (bfd_vma) strtoull (optarg, &end, 0));
 514
 515   if (end == optarg)
 516     einfo (_("%P%F: invalid hex number for PE parameter '%s'\n"), optarg);
 517
 518   optarg = end;
 519 }
 520
 521
 522 static void
 523 set_pep_stack_heap (char *resname, char *comname)
 524 {
 525   set_pep_value (resname);
 526
 527   if (*optarg == ',')
 528     {
 529       optarg++;
 530       set_pep_value (comname);
 531     }
 532   else if (*optarg)
 533     einfo (_("%P%F: strange hex info for PE parameter '%s'\n"), optarg);
 534 }
 535
 536
 537 static bfd_boolean
 538 gld${EMULATION_NAME}_handle_option (int optc)
 539 {
 540   switch (optc)
 541     {
 542     default:
 543       return FALSE;
 544
 545     case OPTION_BASE_FILE:
 546       link_info.base_file = fopen (optarg, FOPEN_WB);
 547       if (link_info.base_file == NULL)
 548         {
 549           /* xgettext:c-format */
 550           fprintf (stderr, _("%s: Can't open base file %s\n"),
 551                    program_name, optarg);
 552           xexit (1);
 553         }
 554       break;
 555
 556       /* PE options.  */
 557     case OPTION_HEAP:
 558       set_pep_stack_heap ("__size_of_heap_reserve__", "__size_of_heap_commit__");
 559       break;
 560     case OPTION_STACK:
 561       set_pep_stack_heap ("__size_of_stack_reserve__", "__size_of_stack_commit__");
 562       break;
 563     case OPTION_SUBSYSTEM:
 564       set_pep_subsystem ();
 565       break;
 566     case OPTION_MAJOR_OS_VERSION:
 567       set_pep_value ("__major_os_version__");
 568       break;
 569     case OPTION_MINOR_OS_VERSION:
 570       set_pep_value ("__minor_os_version__");
 571       break;
 572     case OPTION_MAJOR_SUBSYSTEM_VERSION:
 573       set_pep_value ("__major_subsystem_version__");
 574       break;
 575     case OPTION_MINOR_SUBSYSTEM_VERSION:
 576       set_pep_value ("__minor_subsystem_version__");
 577       break;
 578     case OPTION_MAJOR_IMAGE_VERSION:
 579       set_pep_value ("__major_image_version__");
 580       break;
 581     case OPTION_MINOR_IMAGE_VERSION:
 582       set_pep_value ("__minor_image_version__");
 583       break;
 584     case OPTION_FILE_ALIGNMENT:
 585       set_pep_value ("__file_alignment__");
 586       break;
 587     case OPTION_SECTION_ALIGNMENT:
 588       set_pep_value ("__section_alignment__");
 589       break;
 590     case OPTION_DLL:
 591       set_pep_name ("__dll__", 1);
 592       break;
 593     case OPTION_IMAGE_BASE:
 594       set_pep_value ("__image_base__");
 595       break;
 596     case OPTION_SUPPORT_OLD_CODE:
 597       support_old_code = 1;
 598       break;
 599     case OPTION_USE_NUL_PREFIXED_IMPORT_TABLES:
 600       pep_use_nul_prefixed_import_tables = TRUE;
 601       break;
 602 #ifdef DLL_SUPPORT
 603     case OPTION_OUT_DEF:
 604       pep_out_def_filename = xstrdup (optarg);
 605       break;
 606     case OPTION_EXPORT_ALL:
 607       pep_dll_export_everything = 1;
 608       break;
 609     case OPTION_EXCLUDE_SYMBOLS:
 610       pep_dll_add_excludes (optarg, EXCLUDESYMS);
 611       break;
 612     case OPTION_EXCLUDE_LIBS:
 613       pep_dll_add_excludes (optarg, EXCLUDELIBS);
 614       break;
 615     case OPTION_EXCLUDE_MODULES_FOR_IMPLIB:
 616       pep_dll_add_excludes (optarg, EXCLUDEFORIMPLIB);
 617       break;
 618     case OPTION_KILL_ATS:
 619       pep_dll_kill_ats = 1;
 620       break;
 621     case OPTION_STDCALL_ALIASES:
 622       pep_dll_stdcall_aliases = 1;
 623       break;
 624     case OPTION_ENABLE_STDCALL_FIXUP:
 625       pep_enable_stdcall_fixup = 1;
 626       break;
 627     case OPTION_DISABLE_STDCALL_FIXUP:
 628       pep_enable_stdcall_fixup = 0;
 629       break;
 630     case OPTION_IMPLIB_FILENAME:
 631       pep_implib_filename = xstrdup (optarg);
 632       break;
 633     case OPTION_WARN_DUPLICATE_EXPORTS:
 634       pep_dll_warn_dup_exports = 1;
 635       break;
 636     case OPTION_IMP_COMPAT:
 637       pep_dll_compat_implib = 1;
 638       break;
 639     case OPTION_ENABLE_AUTO_IMAGE_BASE:
 640       pep_enable_auto_image_base = 1;
 641       break;
 642     case OPTION_DISABLE_AUTO_IMAGE_BASE:
 643       pep_enable_auto_image_base = 0;
 644       break;
 645     case OPTION_DLL_SEARCH_PREFIX:
 646       pep_dll_search_prefix = xstrdup (optarg);
 647       break;
 648     case OPTION_NO_DEFAULT_EXCLUDES:
 649       pep_dll_do_default_excludes = 0;
 650       break;
 651     case OPTION_DLL_ENABLE_AUTO_IMPORT:
 652       link_info.pei386_auto_import = 1;
 653       break;
 654     case OPTION_DLL_DISABLE_AUTO_IMPORT:
 655       link_info.pei386_auto_import = 0;
 656       break;
 657     case OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC:
 658       link_info.pei386_runtime_pseudo_reloc = 2;
 659       break;
 660     case OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC:
 661       link_info.pei386_runtime_pseudo_reloc = 0;
 662       break;
 663     case OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V1:
 664       link_info.pei386_runtime_pseudo_reloc = 1;
 665       break;
 666     case OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V2:
 667       link_info.pei386_runtime_pseudo_reloc = 2;
 668       break;
 669     case OPTION_ENABLE_EXTRA_PE_DEBUG:
 670       pep_dll_extra_pe_debug = 1;
 671       break;
 672 #endif
 673     case OPTION_ENABLE_LONG_SECTION_NAMES:
 674       pep_use_coff_long_section_names = 1;
 675       break;
 676     case OPTION_DISABLE_LONG_SECTION_NAMES:
 677       pep_use_coff_long_section_names = 0;
 678       break;
 679     /*  Get DLLCharacteristics bits  */
 680     case OPTION_DYNAMIC_BASE:
 681       pe_dll_characteristics |= IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE;
 682       break;
 683     case OPTION_FORCE_INTEGRITY:
 684       pe_dll_characteristics |= IMAGE_DLL_CHARACTERISTICS_FORCE_INTEGRITY;
 685       break;
 686     case OPTION_NX_COMPAT:
 687       pe_dll_characteristics |= IMAGE_DLL_CHARACTERISTICS_NX_COMPAT;
 688       break;
 689     case OPTION_NO_ISOLATION:
 690       pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_NO_ISOLATION;
 691       break;
 692     case OPTION_NO_SEH:
 693       pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_NO_SEH;
 694       break;
 695     case OPTION_NO_BIND:
 696       pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_NO_BIND;
 697       break;
 698     case OPTION_WDM_DRIVER:
 699       pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_WDM_DRIVER;
 700       break;
 701     case OPTION_TERMINAL_SERVER_AWARE:
 702       pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE;
 703       break;
 704     }
 705
 706   /*  Set DLLCharacteristics bits  */
 707   set_pep_name ("__dll_characteristics__", pe_dll_characteristics);
 708
 709   return TRUE;
 710 }
 711 \f
 712
 713 #ifdef DLL_SUPPORT
 714 static unsigned long
 715 strhash (const char *str)
 716 {
 717   const unsigned char *s;
 718   unsigned long hash;
 719   unsigned int c;
 720   unsigned int len;
 721
 722   hash = 0;
 723   len = 0;
 724   s = (const unsigned char *) str;
 725   while ((c = *s++) != '\0')
 726     {
 727       hash += c + (c << 17);
 728       hash ^= hash >> 2;
 729       ++len;
 730     }
 731   hash += len + (len << 17);
 732   hash ^= hash >> 2;
 733
 734   return hash;
 735 }
 736
 737 /* Use the output file to create a image base for relocatable DLLs.  */
 738
 739 static bfd_vma
 740 compute_dll_image_base (const char *ofile)
 741 {
 742   bfd_vma hash = (bfd_vma) strhash (ofile);
 743   return 0x61300000 + ((hash << 16) & 0x0FFC0000);
 744 }
 745 #endif
 746
 747 /* Assign values to the special symbols before the linker script is
 748    read.  */
 749
 750 static void
 751 gld_${EMULATION_NAME}_set_symbols (void)
 752 {
 753   /* Run through and invent symbols for all the
 754      names and insert the defaults.  */
 755   int j;
 756
 757   if (!init[IMAGEBASEOFF].inited)
 758     {
 759       if (link_info.relocatable)
 760         init[IMAGEBASEOFF].value = 0;
 761       else if (init[DLLOFF].value || (link_info.shared && !link_info.pie))
 762         {
 763 #ifdef DLL_SUPPORT
 764           init[IMAGEBASEOFF].value = (pep_enable_auto_image_base
 765                                       ? compute_dll_image_base (output_filename)
 766                                       : NT_DLL_IMAGE_BASE);
 767 #else
 768           init[IMAGEBASEOFF].value = NT_DLL_IMAGE_BASE;
 769 #endif
 770         }
 771       else
 772         init[IMAGEBASEOFF].value = NT_EXE_IMAGE_BASE;
 773       init[MSIMAGEBASEOFF].value = init[IMAGEBASEOFF].value;
 774     }
 775
 776   /* Don't do any symbol assignments if this is a relocatable link.  */
 777   if (link_info.relocatable)
 778     return;
 779
 780   /* Glue the assignments into the abs section.  */
 781   push_stat_ptr (&abs_output_section->children);
 782
 783   for (j = 0; init[j].ptr; j++)
 784     {
 785       bfd_vma val = init[j].value;
 786       lang_assignment_statement_type *rv;
 787       rv = lang_add_assignment (exp_assop ('=', init[j].symbol,
 788                                            exp_intop (val)));
 789       if (init[j].size == sizeof (short))
 790         *(short *) init[j].ptr = (short) val;
 791       else if (init[j].size == sizeof (int))
 792         *(int *) init[j].ptr = (int) val;
 793       else if (init[j].size == sizeof (long))
 794         *(long *) init[j].ptr = (long) val;
 795       /* This might be a long long or other special type.  */
 796       else if (init[j].size == sizeof (bfd_vma))
 797         *(bfd_vma *) init[j].ptr = val;
 798       else      abort ();
 799       if (j == IMAGEBASEOFF)
 800         image_base_statement = rv;
 801     }
 802   /* Restore the pointer.  */
 803   pop_stat_ptr ();
 804
 805   if (pep.FileAlignment > pep.SectionAlignment)
 806     {
 807       einfo (_("%P: warning, file alignment > section alignment.\n"));
 808     }
 809 }
 810
 811 /* This is called after the linker script and the command line options
 812    have been read.  */
 813
 814 static void
 815 gld_${EMULATION_NAME}_after_parse (void)
 816 {
 817   /* The Windows libraries are designed for the linker to treat the
 818      entry point as an undefined symbol.  Otherwise, the .obj that
 819      defines mainCRTStartup is brought in because it is the first
 820      encountered in libc.lib and it has other symbols in it which will
 821      be pulled in by the link process.  To avoid this, we act as
 822      though the user specified -u with the entry point symbol.
 823
 824      This function is called after the linker script and command line
 825      options have been read, so at this point we know the right entry
 826      point.  This function is called before the input files are
 827      opened, so registering the symbol as undefined will make a
 828      difference.  */
 829
 830   if (! link_info.relocatable && entry_symbol.name != NULL)
 831     ldlang_add_undef (entry_symbol.name);
 832
 833   /* PR ld/6744:  Warn the user if they have used an ELF-only
 834      option hoping it will work on PE+.  */
 835   if (link_info.export_dynamic)
 836     einfo (_("%P: warning: --export-dynamic is not supported for PE+ "
 837       "targets, did you mean --export-all-symbols?\n"));
 838 }
 839
 840 /* pep-dll.c directly accesses pep_data_import_dll,
 841    so it must be defined outside of #ifdef DLL_SUPPORT.
 842    Note - this variable is deliberately not initialised.
 843    This allows it to be treated as a common varaible, and only
 844    exist in one incarnation in a multiple target enabled linker.  */
 845 char * pep_data_import_dll;
 846
 847 #ifdef DLL_SUPPORT
 848 static struct bfd_link_hash_entry *pep_undef_found_sym;
 849
 850 static bfd_boolean
 851 pep_undef_cdecl_match (struct bfd_link_hash_entry *h, void *inf)
 852 {
 853   int sl;
 854   char *string = inf;
 855
 856   sl = strlen (string);
 857   if (h->type == bfd_link_hash_defined
 858       && strncmp (h->root.string, string, sl) == 0
 859       && h->root.string[sl] == '@')
 860     {
 861       pep_undef_found_sym = h;
 862       return FALSE;
 863     }
 864   return TRUE;
 865 }
 866
 867 static void
 868 pep_fixup_stdcalls (void)
 869 {
 870   static int gave_warning_message = 0;
 871   struct bfd_link_hash_entry *undef, *sym;
 872
 873   if (pep_dll_extra_pe_debug)
 874     printf ("%s\n", __FUNCTION__);
 875
 876   for (undef = link_info.hash->undefs; undef; undef=undef->u.undef.next)
 877     if (undef->type == bfd_link_hash_undefined)
 878       {
 879         char* at = strchr (undef->root.string, '@');
 880         int lead_at = (*undef->root.string == '@');
 881         /* For now, don't try to fixup fastcall symbols.  */
 882
 883         if (at && !lead_at)
 884           {
 885             /* The symbol is a stdcall symbol, so let's look for a
 886                cdecl symbol with the same name and resolve to that.  */
 887             char *cname = xstrdup (undef->root.string /* + lead_at */);
 888             at = strchr (cname, '@');
 889             *at = 0;
 890             sym = bfd_link_hash_lookup (link_info.hash, cname, 0, 0, 1);
 891
 892             if (sym && sym->type == bfd_link_hash_defined)
 893               {
 894                 undef->type = bfd_link_hash_defined;
 895                 undef->u.def.value = sym->u.def.value;
 896                 undef->u.def.section = sym->u.def.section;
 897
 898                 if (pep_enable_stdcall_fixup == -1)
 899                   {
 900                     einfo (_("Warning: resolving %s by linking to %s\n"),
 901                            undef->root.string, cname);
 902                     if (! gave_warning_message)
 903                       {
 904                         gave_warning_message = 1;
 905                         einfo (_("Use --enable-stdcall-fixup to disable these warnings\n"));
 906                         einfo (_("Use --disable-stdcall-fixup to disable these fixups\n"));
 907                       }
 908                   }
 909               }
 910           }
 911         else
 912           {
 913             /* The symbol is a cdecl symbol, so we look for stdcall
 914                symbols - which means scanning the whole symbol table.  */
 915             pep_undef_found_sym = 0;
 916             bfd_link_hash_traverse (link_info.hash, pep_undef_cdecl_match,
 917                                     (char *) undef->root.string);
 918             sym = pep_undef_found_sym;
 919             if (sym)
 920               {
 921                 undef->type = bfd_link_hash_defined;
 922                 undef->u.def.value = sym->u.def.value;
 923                 undef->u.def.section = sym->u.def.section;
 924
 925                 if (pep_enable_stdcall_fixup == -1)
 926                   {
 927                     einfo (_("Warning: resolving %s by linking to %s\n"),
 928                            undef->root.string, sym->root.string);
 929                     if (! gave_warning_message)
 930                       {
 931                         gave_warning_message = 1;
 932                         einfo (_("Use --enable-stdcall-fixup to disable these warnings\n"));
 933                         einfo (_("Use --disable-stdcall-fixup to disable these fixups\n"));
 934                       }
 935                   }
 936               }
 937           }
 938       }
 939 }
 940
 941 static int
 942 make_import_fixup (arelent *rel, asection *s)
 943 {
 944   struct bfd_symbol *sym = *rel->sym_ptr_ptr;
 945   char addend[8];
 946   bfd_vma _addend = 0;
 947   int suc = 0;
 948
 949   if (pep_dll_extra_pe_debug)
 950     printf ("arelent: %s@%#lx: add=%li\n", sym->name,
 951             (unsigned long) rel->address, (long) rel->addend);
 952
 953   memset (addend, 0, sizeof (addend));
 954   switch ((rel->howto->bitsize))
 955     {
 956       case 8:
 957         suc = bfd_get_section_contents (s->owner, s, addend, rel->address, 1);
 958         if (suc && rel->howto->pc_relative)
 959           _addend = (bfd_vma) ((bfd_signed_vma) ((char) bfd_get_8 (s->owner, addend)));
 960         else if (suc)
 961           _addend = ((bfd_vma) bfd_get_8 (s->owner, addend)) & 0xff;
 962         break;
 963       case 16:
 964         suc = bfd_get_section_contents (s->owner, s, addend, rel->address, 2);
 965         if (suc && rel->howto->pc_relative)
 966           _addend = (bfd_vma) ((bfd_signed_vma) ((short) bfd_get_16 (s->owner, addend)));
 967         else if (suc)
 968           _addend = ((bfd_vma) bfd_get_16 (s->owner, addend)) & 0xffff;
 969         break;
 970       case 32:
 971         suc = bfd_get_section_contents (s->owner, s, addend, rel->address, 4);
 972         if (suc && rel->howto->pc_relative)
 973           _addend = (bfd_vma) ((bfd_signed_vma) ((int) bfd_get_32 (s->owner, addend)));
 974         else if (suc)
 975           _addend = ((bfd_vma) bfd_get_32 (s->owner, addend)) & 0xffffffff;
 976         break;
 977       case 64:
 978         suc = bfd_get_section_contents (s->owner, s, addend, rel->address, 8);
 979         if (suc)
 980           _addend = ((bfd_vma) bfd_get_64 (s->owner, addend));
 981         break;
 982     }
 983   if (! suc)
 984     einfo (_("%C: Cannot get section contents - auto-import exception\n"),
 985            s->owner, s, rel->address);
 986
 987   if (pep_dll_extra_pe_debug)
 988     {
 989       printf ("import of 0x%lx(0x%lx) sec_addr=0x%lx", (long) _addend, (long) rel->addend, (long) rel->address);
 990       if (rel->howto->pc_relative) printf (" pcrel");
 991       printf (" %d bit rel.\n",(int) rel->howto->bitsize);
 992   }
 993   pep_create_import_fixup (rel, s, _addend);
 994
 995   return 1;
 996 }
 997
 998 static void
 999 pep_find_data_imports (void)
1000 {
1001   struct bfd_link_hash_entry *undef, *sym;
1002
1003   if (link_info.pei386_auto_import == 0)
1004     return;
1005
1006   for (undef = link_info.hash->undefs; undef; undef=undef->u.undef.next)
1007     {
1008       if (undef->type == bfd_link_hash_undefined)
1009         {
1010           /* C++ symbols are *long*.  */
1011           char buf[4096];
1012
1013           if (pep_dll_extra_pe_debug)
1014             printf ("%s:%s\n", __FUNCTION__, undef->root.string);
1015
1016           sprintf (buf, "__imp_%s", undef->root.string);
1017
1018           sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
1019
1020           if (sym && sym->type == bfd_link_hash_defined)
1021             {
1022               bfd *b = sym->u.def.section->owner;
1023               asymbol **symbols;
1024               int nsyms, i;
1025
1026               if (link_info.pei386_auto_import == -1)
1027                 {
1028                   static bfd_boolean warned = FALSE;
1029
1030                   info_msg (_("Info: resolving %s by linking to %s (auto-import)\n"),
1031                             undef->root.string, buf);
1032
1033                   /* PR linker/4844.  */
1034                   if (! warned)
1035                     {
1036                       warned = TRUE;
1037                       einfo (_("%P: warning: auto-importing has been activated without --enable-auto-import specified on the command line.\n\
1038 This should work unless it involves constant data structures referencing symbols from auto-imported DLLs.\n"));
1039                     }
1040                 }
1041
1042               if (!bfd_generic_link_read_symbols (b))
1043                 {
1044                   einfo (_("%B%F: could not read symbols: %E\n"), b);
1045                   return;
1046                 }
1047
1048               symbols = bfd_get_outsymbols (b);
1049               nsyms = bfd_get_symcount (b);
1050
1051               for (i = 0; i < nsyms; i++)
1052                 {
1053                   if (! CONST_STRNEQ (symbols[i]->name, "__head_"))
1054                     continue;
1055
1056                   if (pep_dll_extra_pe_debug)
1057                     printf ("->%s\n", symbols[i]->name);
1058
1059                   pep_data_import_dll = (char*) (symbols[i]->name +
1060                                                 sizeof ("__head_") - 1);
1061                   break;
1062                 }
1063
1064               pep_walk_relocs_of_symbol (&link_info, undef->root.string,
1065                                          make_import_fixup);
1066
1067               /* Let's differentiate it somehow from defined.  */
1068               undef->type = bfd_link_hash_defweak;
1069               /* We replace original name with __imp_ prefixed, this
1070                  1) may trash memory 2) leads to duplicate symbol generation.
1071                  Still, IMHO it's better than having name poluted.  */
1072               undef->root.string = sym->root.string;
1073               undef->u.def.value = sym->u.def.value;
1074               undef->u.def.section = sym->u.def.section;
1075             }
1076         }
1077     }
1078 }
1079
1080 static bfd_boolean
1081 pr_sym (struct bfd_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
1082 {
1083   if (pep_dll_extra_pe_debug)
1084     printf ("+%s\n", h->string);
1085
1086   return TRUE;
1087 }
1088 #endif /* DLL_SUPPORT */
1089
1090 static void
1091 debug_section_p (bfd *abfd ATTRIBUTE_UNUSED, asection *sect, void *obj)
1092 {
1093   int *found = (int *) obj;
1094   if (strncmp (".debug_", sect->name, sizeof (".debug_") - 1) == 0)
1095     *found = 1;
1096 }
1097
1098 static void
1099 gld_${EMULATION_NAME}_after_open (void)
1100 {
1101 #ifdef DLL_SUPPORT
1102   if (pep_dll_extra_pe_debug)
1103     {
1104       bfd *a;
1105       struct bfd_link_hash_entry *sym;
1106
1107       printf ("%s()\n", __FUNCTION__);
1108
1109       for (sym = link_info.hash->undefs; sym; sym=sym->u.undef.next)
1110         printf ("-%s\n", sym->root.string);
1111       bfd_hash_traverse (&link_info.hash->table, pr_sym, NULL);
1112
1113       for (a = link_info.input_bfds; a; a = a->link_next)
1114         printf ("*%s\n",a->filename);
1115     }
1116 #endif
1117
1118   /* Pass the wacky PE command line options into the output bfd.
1119      FIXME: This should be done via a function, rather than by
1120      including an internal BFD header.  */
1121
1122   if (coff_data (link_info.output_bfd) == NULL
1123       || coff_data (link_info.output_bfd)->pe == 0)
1124     einfo (_("%F%P: cannot perform PE operations on non PE output file '%B'.\n"),
1125            link_info.output_bfd);
1126
1127   pe_data (link_info.output_bfd)->pe_opthdr = pep;
1128   pe_data (link_info.output_bfd)->dll = init[DLLOFF].value;
1129   pe_data (link_info.output_bfd)->real_flags |= real_flags;
1130
1131   /* At this point we must decide whether to use long section names
1132      in the output or not.  If the user hasn't explicitly specified
1133      on the command line, we leave it to the default for the format
1134      (object files yes, image files no), except if there is debug
1135      information present; GDB relies on the long section names to
1136      find it, so enable it in that case.  */
1137   if (pep_use_coff_long_section_names < 0 && link_info.strip == strip_none)
1138     {
1139       /* Iterate over all sections of all input BFDs, checking
1140          for any that begin 'debug_' and are long names.  */
1141       LANG_FOR_EACH_INPUT_STATEMENT (is)
1142         {
1143           int found_debug = 0;
1144           bfd_map_over_sections (is->the_bfd, debug_section_p, &found_debug);
1145           if (found_debug)
1146             {
1147               pep_use_coff_long_section_names = 1;
1148               break;
1149             }
1150         }
1151     }
1152
1153   pep_output_file_set_long_section_names (link_info.output_bfd);
1154
1155 #ifdef DLL_SUPPORT
1156   if (pep_enable_stdcall_fixup) /* -1=warn or 1=disable */
1157     pep_fixup_stdcalls ();
1158
1159   pep_process_import_defs (link_info.output_bfd, &link_info);
1160
1161   pep_find_data_imports ();
1162
1163 #ifndef TARGET_IS_i386pep
1164   if (link_info.shared)
1165 #else
1166   if (!link_info.relocatable)
1167 #endif
1168     pep_dll_build_sections (link_info.output_bfd, &link_info);
1169
1170 #ifndef TARGET_IS_i386pep
1171   else
1172     pep_exe_build_sections (link_info.output_bfd, &link_info);
1173 #endif
1174 #endif /* DLL_SUPPORT */
1175
1176   {
1177     /* This next chunk of code tries to detect the case where you have
1178        two import libraries for the same DLL (specifically,
1179        symbolically linking libm.a and libc.a in cygwin to
1180        libcygwin.a).  In those cases, it's possible for function
1181        thunks from the second implib to be used but without the
1182        head/tail objects, causing an improper import table.  We detect
1183        those cases and rename the "other" import libraries to match
1184        the one the head/tail come from, so that the linker will sort
1185        things nicely and produce a valid import table.  */
1186
1187     LANG_FOR_EACH_INPUT_STATEMENT (is)
1188       {
1189         if (is->the_bfd->my_archive)
1190           {
1191             int idata2 = 0, reloc_count=0, is_imp = 0;
1192             asection *sec;
1193
1194             /* See if this is an import library thunk.  */
1195             for (sec = is->the_bfd->sections; sec; sec = sec->next)
1196               {
1197                 if (strcmp (sec->name, ".idata\$2") == 0)
1198                   idata2 = 1;
1199                 if (CONST_STRNEQ (sec->name, ".idata\$"))
1200                   is_imp = 1;
1201                 reloc_count += sec->reloc_count;
1202               }
1203
1204             if (is_imp && !idata2 && reloc_count)
1205               {
1206                 /* It is, look for the reference to head and see if it's
1207                    from our own library.  */
1208                 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1209                   {
1210                     int i;
1211                     long relsize;
1212                     asymbol **symbols;
1213                     arelent **relocs;
1214                     int nrelocs;
1215
1216                     relsize = bfd_get_reloc_upper_bound (is->the_bfd, sec);
1217                     if (relsize < 1)
1218                       break;
1219
1220                     if (!bfd_generic_link_read_symbols (is->the_bfd))
1221                       {
1222                         einfo (_("%B%F: could not read symbols: %E\n"),
1223                                is->the_bfd);
1224                         return;
1225                       }
1226                     symbols = bfd_get_outsymbols (is->the_bfd);
1227
1228                     relocs = xmalloc ((size_t) relsize);
1229                     nrelocs = bfd_canonicalize_reloc (is->the_bfd, sec,
1230                                                       relocs, symbols);
1231                     if (nrelocs < 0)
1232                       {
1233                         free (relocs);
1234                         einfo ("%X%P: unable to process relocs: %E\n");
1235                         return;
1236                       }
1237
1238                     for (i = 0; i < nrelocs; i++)
1239                       {
1240                         struct bfd_symbol *s;
1241                         struct bfd_link_hash_entry * blhe;
1242                         char *other_bfd_filename;
1243                         char *n;
1244
1245                         s = (relocs[i]->sym_ptr_ptr)[0];
1246
1247                         if (s->flags & BSF_LOCAL)
1248                           continue;
1249
1250                         /* Thunk section with reloc to another bfd.  */
1251                         blhe = bfd_link_hash_lookup (link_info.hash,
1252                                                      s->name,
1253                                                      FALSE, FALSE, TRUE);
1254
1255                         if (blhe == NULL
1256                             || blhe->type != bfd_link_hash_defined)
1257                           continue;
1258
1259                         other_bfd_filename
1260                           = blhe->u.def.section->owner->my_archive
1261                             ? bfd_get_filename (blhe->u.def.section->owner->my_archive)
1262                             : bfd_get_filename (blhe->u.def.section->owner);
1263
1264                         if (strcmp (bfd_get_filename (is->the_bfd->my_archive),
1265                                     other_bfd_filename) == 0)
1266                           continue;
1267
1268                         /* Rename this implib to match the other one.  */
1269                         n = xmalloc (strlen (other_bfd_filename) + 1);
1270                         strcpy (n, other_bfd_filename);
1271                         is->the_bfd->my_archive->filename = n;
1272                       }
1273
1274                     free (relocs);
1275                     /* Note - we do not free the symbols,
1276                        they are now cached in the BFD.  */
1277                   }
1278               }
1279           }
1280       }
1281   }
1282
1283   {
1284     int is_ms_arch = 0;
1285     bfd *cur_arch = 0;
1286     lang_input_statement_type *is2;
1287     lang_input_statement_type *is3;
1288
1289     /* Careful - this is a shell script.  Watch those dollar signs! */
1290     /* Microsoft import libraries have every member named the same,
1291        and not in the right order for us to link them correctly.  We
1292        must detect these and rename the members so that they'll link
1293        correctly.  There are three types of objects: the head, the
1294        thunks, and the sentinel(s).  The head is easy; it's the one
1295        with idata2.  We assume that the sentinels won't have relocs,
1296        and the thunks will.  It's easier than checking the symbol
1297        table for external references.  */
1298     LANG_FOR_EACH_INPUT_STATEMENT (is)
1299       {
1300         if (is->the_bfd->my_archive)
1301           {
1302             char *pnt;
1303             bfd *arch = is->the_bfd->my_archive;
1304
1305             if (cur_arch != arch)
1306               {
1307                 cur_arch = arch;
1308                 is_ms_arch = 1;
1309
1310                 for (is3 = is;
1311                      is3 && is3->the_bfd->my_archive == arch;
1312                      is3 = (lang_input_statement_type *) is3->next)
1313                   {
1314                     /* A MS dynamic import library can also contain static
1315                        members, so look for the first element with a .dll
1316                        extension, and use that for the remainder of the
1317                        comparisons.  */
1318                     pnt = strrchr (is3->the_bfd->filename, '.');
1319                     if (pnt != NULL && strcmp (pnt, ".dll") == 0)
1320                       break;
1321                   }
1322
1323                 if (is3 == NULL)
1324                   is_ms_arch = 0;
1325                 else
1326                   {
1327                     /* OK, found one.  Now look to see if the remaining
1328                        (dynamic import) members use the same name.  */
1329                     for (is2 = is;
1330                          is2 && is2->the_bfd->my_archive == arch;
1331                          is2 = (lang_input_statement_type *) is2->next)
1332                       {
1333                         /* Skip static members, ie anything with a .obj
1334                            extension.  */
1335                         pnt = strrchr (is2->the_bfd->filename, '.');
1336                         if (pnt != NULL && strcmp (pnt, ".obj") == 0)
1337                           continue;
1338
1339                         if (strcmp (is3->the_bfd->filename,
1340                                     is2->the_bfd->filename))
1341                           {
1342                             is_ms_arch = 0;
1343                             break;
1344                           }
1345                       }
1346                   }
1347               }
1348
1349             /* This fragment might have come from an .obj file in a Microsoft
1350                import, and not an actual import record. If this is the case,
1351                then leave the filename alone.  */
1352             pnt = strrchr (is->the_bfd->filename, '.');
1353
1354             if (is_ms_arch && (strcmp (pnt, ".dll") == 0))
1355               {
1356                 int idata2 = 0, reloc_count=0;
1357                 asection *sec;
1358                 char *new_name, seq;
1359
1360                 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1361                   {
1362                     if (strcmp (sec->name, ".idata\$2") == 0)
1363                       idata2 = 1;
1364                     reloc_count += sec->reloc_count;
1365                   }
1366
1367                 if (idata2) /* .idata2 is the TOC */
1368                   seq = 'a';
1369                 else if (reloc_count > 0) /* thunks */
1370                   seq = 'b';
1371                 else /* sentinel */
1372                   seq = 'c';
1373
1374                 new_name = xmalloc (strlen (is->the_bfd->filename) + 3);
1375                 sprintf (new_name, "%s.%c", is->the_bfd->filename, seq);
1376                 is->the_bfd->filename = new_name;
1377
1378                 new_name = xmalloc (strlen (is->filename) + 3);
1379                 sprintf (new_name, "%s.%c", is->filename, seq);
1380                 is->filename = new_name;
1381               }
1382           }
1383       }
1384   }
1385 }
1386 \f
1387 static void
1388 gld_${EMULATION_NAME}_before_allocation (void)
1389 {
1390   before_allocation_default ();
1391 }
1392 \f
1393 #ifdef DLL_SUPPORT
1394 /* This is called when an input file isn't recognized as a BFD.  We
1395    check here for .DEF files and pull them in automatically.  */
1396
1397 static int
1398 saw_option (char *option)
1399 {
1400   int i;
1401
1402   for (i = 0; init[i].ptr; i++)
1403     if (strcmp (init[i].symbol, option) == 0)
1404       return init[i].inited;
1405   return 0;
1406 }
1407 #endif /* DLL_SUPPORT */
1408
1409 static bfd_boolean
1410 gld_${EMULATION_NAME}_unrecognized_file (lang_input_statement_type *entry ATTRIBUTE_UNUSED)
1411 {
1412 #ifdef DLL_SUPPORT
1413   const char *ext = entry->filename + strlen (entry->filename) - 4;
1414
1415   if (strcmp (ext, ".def") == 0 || strcmp (ext, ".DEF") == 0)
1416     {
1417       pep_def_file = def_file_parse (entry->filename, pep_def_file);
1418
1419       if (pep_def_file)
1420         {
1421           int i, buflen=0, len;
1422           char *buf;
1423
1424           for (i = 0; i < pep_def_file->num_exports; i++)
1425             {
1426               len = strlen (pep_def_file->exports[i].internal_name);
1427               if (buflen < len + 2)
1428                 buflen = len + 2;
1429             }
1430
1431           buf = xmalloc (buflen);
1432
1433           for (i = 0; i < pep_def_file->num_exports; i++)
1434             {
1435               struct bfd_link_hash_entry *h;
1436
1437               sprintf (buf, "_%s", pep_def_file->exports[i].internal_name);
1438
1439               h = bfd_link_hash_lookup (link_info.hash, buf, TRUE, TRUE, TRUE);
1440               if (h == (struct bfd_link_hash_entry *) NULL)
1441                 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1442               if (h->type == bfd_link_hash_new)
1443                 {
1444                   h->type = bfd_link_hash_undefined;
1445                   h->u.undef.abfd = NULL;
1446                   bfd_link_add_undef (link_info.hash, h);
1447                 }
1448             }
1449           free (buf);
1450
1451           /* def_file_print (stdout, pep_def_file); */
1452           if (pep_def_file->is_dll == 1)
1453             link_info.shared = 1;
1454
1455           if (pep_def_file->base_address != (bfd_vma)(-1))
1456             {
1457               pep.ImageBase
1458                 = pe_data (link_info.output_bfd)->pe_opthdr.ImageBase
1459                 = init[IMAGEBASEOFF].value
1460                 = pep_def_file->base_address;
1461               init[IMAGEBASEOFF].inited = 1;
1462               if (image_base_statement)
1463                 image_base_statement->exp = exp_assop ('=', "__image_base__",
1464                                                        exp_intop (pep.ImageBase));
1465             }
1466
1467           if (pep_def_file->stack_reserve != -1
1468               && ! saw_option ("__size_of_stack_reserve__"))
1469             {
1470               pep.SizeOfStackReserve = pep_def_file->stack_reserve;
1471               if (pep_def_file->stack_commit != -1)
1472                 pep.SizeOfStackCommit = pep_def_file->stack_commit;
1473             }
1474           if (pep_def_file->heap_reserve != -1
1475               && ! saw_option ("__size_of_heap_reserve__"))
1476             {
1477               pep.SizeOfHeapReserve = pep_def_file->heap_reserve;
1478               if (pep_def_file->heap_commit != -1)
1479                 pep.SizeOfHeapCommit = pep_def_file->heap_commit;
1480             }
1481           return TRUE;
1482         }
1483     }
1484 #endif
1485   return FALSE;
1486 }
1487
1488 static bfd_boolean
1489 gld_${EMULATION_NAME}_recognized_file (lang_input_statement_type *entry ATTRIBUTE_UNUSED)
1490 {
1491 #ifdef DLL_SUPPORT
1492 #ifdef TARGET_IS_i386pep
1493   pep_dll_id_target ("pei-x86-64");
1494 #endif
1495   if (pep_bfd_is_dll (entry->the_bfd))
1496     return pep_implied_import_dll (entry->filename);
1497 #endif
1498   return FALSE;
1499 }
1500
1501 static void
1502 gld_${EMULATION_NAME}_finish (void)
1503 {
1504   finish_default ();
1505
1506 #ifdef DLL_SUPPORT
1507   if (link_info.shared
1508       || (!link_info.relocatable && pep_def_file->num_exports != 0))
1509     {
1510       pep_dll_fill_sections (link_info.output_bfd, &link_info);
1511       if (pep_implib_filename)
1512         pep_dll_generate_implib (pep_def_file, pep_implib_filename, &link_info);
1513     }
1514
1515   if (pep_out_def_filename)
1516     pep_dll_generate_def_file (pep_out_def_filename);
1517 #endif /* DLL_SUPPORT */
1518
1519   /* I don't know where .idata gets set as code, but it shouldn't be.  */
1520   {
1521     asection *asec = bfd_get_section_by_name (link_info.output_bfd, ".idata");
1522
1523     if (asec)
1524       {
1525         asec->flags &= ~SEC_CODE;
1526         asec->flags |= SEC_DATA;
1527       }
1528   }
1529 }
1530
1531 \f
1532 /* Place an orphan section.
1533
1534    We use this to put sections in a reasonable place in the file, and
1535    to ensure that they are aligned as required.
1536
1537    We handle grouped sections here as well.  A section named .foo\$nn
1538    goes into the output section .foo.  All grouped sections are sorted
1539    by name.
1540
1541    Grouped sections for the default sections are handled by the
1542    default linker script using wildcards, and are sorted by
1543    sort_sections.  */
1544
1545 static lang_output_section_statement_type *
1546 gld_${EMULATION_NAME}_place_orphan (asection *s,
1547                                     const char *secname,
1548                                     int constraint)
1549 {
1550   const char *orig_secname = secname;
1551   char *dollar = NULL;
1552   lang_output_section_statement_type *os;
1553   lang_statement_list_type add_child;
1554   lang_statement_union_type **pl;
1555
1556   /* Look through the script to see where to place this section.  */
1557   if (!link_info.relocatable
1558       && (dollar = strchr (secname, '\$')) != NULL)
1559     {
1560       size_t len = dollar - secname;
1561       char *newname = xmalloc (len + 1);
1562       memcpy (newname, secname, len);
1563       newname[len] = '\0';
1564       secname = newname;
1565     }
1566
1567   lang_list_init (&add_child);
1568
1569   os = NULL;
1570   if (constraint == 0)
1571     for (os = lang_output_section_find (secname);
1572          os != NULL;
1573          os = next_matching_output_section_statement (os, 0))
1574       {
1575         /* If we don't match an existing output section, tell
1576            lang_insert_orphan to create a new output section.  */
1577         constraint = SPECIAL;
1578
1579         if (os->bfd_section != NULL
1580             && (os->bfd_section->flags == 0
1581                 || ((s->flags ^ os->bfd_section->flags)
1582                     & (SEC_LOAD | SEC_ALLOC)) == 0))
1583           {
1584             /* We already have an output section statement with this
1585                name, and its bfd section has compatible flags.
1586                If the section already exists but does not have any flags set,
1587                then it has been created by the linker, probably as a result of
1588                a --section-start command line switch.  */
1589             lang_add_section (&add_child, s, os);
1590             break;
1591           }
1592       }
1593
1594   if (os == NULL)
1595     {
1596       static struct orphan_save hold[] =
1597         {
1598           { ".text",
1599             SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE,
1600             0, 0, 0, 0 },
1601           { ".rdata",
1602             SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
1603             0, 0, 0, 0 },
1604           { ".data",
1605             SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA,
1606             0, 0, 0, 0 },
1607           { ".bss",
1608             SEC_ALLOC,
1609             0, 0, 0, 0 }
1610         };
1611       enum orphan_save_index
1612         {
1613           orphan_text = 0,
1614           orphan_rodata,
1615           orphan_data,
1616           orphan_bss
1617         };
1618       static int orphan_init_done = 0;
1619       struct orphan_save *place;
1620       lang_output_section_statement_type *after;
1621       etree_type *address;
1622
1623       if (!orphan_init_done)
1624         {
1625           struct orphan_save *ho;
1626           for (ho = hold; ho < hold + sizeof (hold) / sizeof (hold[0]); ++ho)
1627             if (ho->name != NULL)
1628               {
1629                 ho->os = lang_output_section_find (ho->name);
1630                 if (ho->os != NULL && ho->os->flags == 0)
1631                   ho->os->flags = ho->flags;
1632               }
1633           orphan_init_done = 1;
1634         }
1635
1636       /* Try to put the new output section in a reasonable place based
1637          on the section name and section flags.  */
1638
1639       place = NULL;
1640       if ((s->flags & SEC_ALLOC) == 0)
1641         ;
1642       else if ((s->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
1643         place = &hold[orphan_bss];
1644       else if ((s->flags & SEC_READONLY) == 0)
1645         place = &hold[orphan_data];
1646       else if ((s->flags & SEC_CODE) == 0)
1647         place = &hold[orphan_rodata];
1648       else
1649         place = &hold[orphan_text];
1650
1651       after = NULL;
1652       if (place != NULL)
1653         {
1654           if (place->os == NULL)
1655             place->os = lang_output_section_find (place->name);
1656           after = place->os;
1657           if (after == NULL)
1658             after = lang_output_section_find_by_flags (s, &place->os, NULL);
1659           if (after == NULL)
1660             /* *ABS* is always the first output section statement.  */
1661             after = (&lang_output_section_statement.head
1662                      ->output_section_statement);
1663         }
1664
1665       /* All sections in an executable must be aligned to a page boundary.  */
1666       address = exp_unop (ALIGN_K, exp_nameop (NAME, "__section_alignment__"));
1667       os = lang_insert_orphan (s, secname, constraint, after, place, address,
1668                                &add_child);
1669     }
1670
1671   /* If the section name has a '\$', sort it with the other '\$'
1672      sections.  */
1673   for (pl = &os->children.head; *pl != NULL; pl = &(*pl)->header.next)
1674     {
1675       lang_input_section_type *ls;
1676       const char *lname;
1677
1678       if ((*pl)->header.type != lang_input_section_enum)
1679         continue;
1680
1681       ls = &(*pl)->input_section;
1682
1683       lname = bfd_get_section_name (ls->section->owner, ls->section);
1684       if (strchr (lname, '\$') != NULL
1685           && (dollar == NULL || strcmp (orig_secname, lname) < 0))
1686         break;
1687     }
1688
1689   if (add_child.head != NULL)
1690     {
1691       *add_child.tail = *pl;
1692       *pl = add_child.head;
1693     }
1694
1695   return os;
1696 }
1697
1698 static bfd_boolean
1699 gld_${EMULATION_NAME}_open_dynamic_archive
1700   (const char *arch ATTRIBUTE_UNUSED,
1701    search_dirs_type *search,
1702    lang_input_statement_type *entry)
1703 {
1704   static const struct
1705     {
1706       const char * format;
1707       bfd_boolean use_prefix;
1708     }
1709   libname_fmt [] =
1710     {
1711       /* Preferred explicit import library for dll's.  */
1712       { "lib%s.dll.a", FALSE },
1713       /* Alternate explicit import library for dll's.  */
1714       { "%s.dll.a", FALSE },
1715       /* "libfoo.a" could be either an import lib or a static lib.
1716           For backwards compatibility, libfoo.a needs to precede
1717           libfoo.dll and foo.dll in the search.  */
1718       { "lib%s.a", FALSE },
1719       /* The 'native' spelling of an import lib name is "foo.lib".  */
1720       { "%s.lib", FALSE },
1721 #ifdef DLL_SUPPORT
1722       /* Try "<prefix>foo.dll" (preferred dll name, if specified).  */
1723       { "%s%s.dll", TRUE },
1724 #endif
1725       /* Try "libfoo.dll" (default preferred dll name).  */
1726       { "lib%s.dll", FALSE },
1727       /* Finally try 'native' dll name "foo.dll".  */
1728       {  "%s.dll", FALSE },
1729       /* Note: If adding more formats to this table, make sure to check to
1730          see if their length is longer than libname_fmt[0].format, and if
1731          so, update the call to xmalloc() below.  */
1732       { NULL, FALSE }
1733     };
1734   static unsigned int format_max_len = 0;
1735   const char * filename;
1736   char * full_string;
1737   char * base_string;
1738   unsigned int i;
1739
1740
1741   if (! entry->is_archive)
1742     return FALSE;
1743
1744   filename = entry->filename;
1745
1746   if (format_max_len == 0)
1747     /* We need to allow space in the memory that we are going to allocate
1748        for the characters in the format string.  Since the format array is
1749        static we only need to calculate this information once.  In theory
1750        this value could also be computed statically, but this introduces
1751        the possibility for a discrepancy and hence a possible memory
1752        corruption.  The lengths we compute here will be too long because
1753        they will include any formating characters (%s) in the strings, but
1754        this will not matter.  */
1755     for (i = 0; libname_fmt[i].format; i++)
1756       if (format_max_len < strlen (libname_fmt[i].format))
1757         format_max_len = strlen (libname_fmt[i].format);
1758
1759   full_string = xmalloc (strlen (search->name)
1760                          + strlen (filename)
1761                          + format_max_len
1762 #ifdef DLL_SUPPORT
1763                          + (pep_dll_search_prefix
1764                             ? strlen (pep_dll_search_prefix) : 0)
1765 #endif
1766                          /* Allow for the terminating NUL and for the path
1767                             separator character that is inserted between
1768                             search->name and the start of the format string.  */
1769                          + 2);
1770
1771   sprintf (full_string, "%s/", search->name);
1772   base_string = full_string + strlen (full_string);
1773
1774   for (i = 0; libname_fmt[i].format; i++)
1775     {
1776 #ifdef DLL_SUPPORT
1777       if (libname_fmt[i].use_prefix)
1778         {
1779           if (!pep_dll_search_prefix)
1780             continue;
1781           sprintf (base_string, libname_fmt[i].format, pep_dll_search_prefix, filename);
1782         }
1783       else
1784 #endif
1785         sprintf (base_string, libname_fmt[i].format, filename);
1786
1787       if (ldfile_try_open_bfd (full_string, entry))
1788         break;
1789     }
1790
1791   if (!libname_fmt[i].format)
1792     {
1793       free (full_string);
1794       return FALSE;
1795     }
1796
1797   entry->filename = full_string;
1798
1799   return TRUE;
1800 }
1801
1802 static int
1803 gld_${EMULATION_NAME}_find_potential_libraries
1804   (char *name, lang_input_statement_type *entry)
1805 {
1806   return ldfile_open_file_search (name, entry, "", ".lib");
1807 }
1808 \f
1809 static char *
1810 gld_${EMULATION_NAME}_get_script (int *isfile)
1811 EOF
1812 # Scripts compiled in.
1813 # sed commands to quote an ld script as a C string.
1814 sc="-f stringify.sed"
1815
1816 fragment <<EOF
1817 {
1818   *isfile = 0;
1819
1820   if (link_info.relocatable && config.build_constructors)
1821     return
1822 EOF
1823 sed $sc ldscripts/${EMULATION_NAME}.xu                  >> e${EMULATION_NAME}.c
1824 echo '  ; else if (link_info.relocatable) return'       >> e${EMULATION_NAME}.c
1825 sed $sc ldscripts/${EMULATION_NAME}.xr                  >> e${EMULATION_NAME}.c
1826 echo '  ; else if (!config.text_read_only) return'      >> e${EMULATION_NAME}.c
1827 sed $sc ldscripts/${EMULATION_NAME}.xbn                 >> e${EMULATION_NAME}.c
1828 echo '  ; else if (!config.magic_demand_paged) return'  >> e${EMULATION_NAME}.c
1829 sed $sc ldscripts/${EMULATION_NAME}.xn                  >> e${EMULATION_NAME}.c
1830 if test -n "$GENERATE_AUTO_IMPORT_SCRIPT" ; then
1831 echo '  ; else if (link_info.pei386_auto_import == 1) return'   >> e${EMULATION_NAME}.c
1832 sed $sc ldscripts/${EMULATION_NAME}.xa                  >> e${EMULATION_NAME}.c
1833 fi
1834 echo '  ; else return'                                  >> e${EMULATION_NAME}.c
1835 sed $sc ldscripts/${EMULATION_NAME}.x                   >> e${EMULATION_NAME}.c
1836 echo '; }'                                              >> e${EMULATION_NAME}.c
1837
1838 fragment <<EOF
1839
1840
1841 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
1842 {
1843   gld_${EMULATION_NAME}_before_parse,
1844   syslib_default,
1845   hll_default,
1846   gld_${EMULATION_NAME}_after_parse,
1847   gld_${EMULATION_NAME}_after_open,
1848   after_allocation_default,
1849   set_output_arch_default,
1850   ldemul_default_target,
1851   gld_${EMULATION_NAME}_before_allocation,
1852   gld_${EMULATION_NAME}_get_script,
1853   "${EMULATION_NAME}",
1854   "${OUTPUT_FORMAT}",
1855   gld_${EMULATION_NAME}_finish,
1856   NULL, /* Create output section statements.  */
1857   gld_${EMULATION_NAME}_open_dynamic_archive,
1858   gld_${EMULATION_NAME}_place_orphan,
1859   gld_${EMULATION_NAME}_set_symbols,
1860   NULL, /* parse_args */
1861   gld${EMULATION_NAME}_add_options,
1862   gld${EMULATION_NAME}_handle_option,
1863   gld_${EMULATION_NAME}_unrecognized_file,
1864   gld_${EMULATION_NAME}_list_options,
1865   gld_${EMULATION_NAME}_recognized_file,
1866   gld_${EMULATION_NAME}_find_potential_libraries,
1867   NULL  /* new_vers_pattern.  */
1868 };
1869 EOF