ld/emultempl/pe.em

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