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