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