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