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