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