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