ld/emultempl/pe.em

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