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