ld/emultempl/pe.em

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