ld/emultempl/pe.em

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