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 (coff_data (link_info.output_bfd) == NULL
1364       || coff_data (link_info.output_bfd)->pe == 0)
1365     einfo (_("%F%P: cannot perform PE operations on non PE output file '%pB'\n"),
1366            link_info.output_bfd);
1367
1368   pe_data (link_info.output_bfd)->pe_opthdr = pe;
1369   pe_data (link_info.output_bfd)->dll = init[DLLOFF].value;
1370   pe_data (link_info.output_bfd)->real_flags |= real_flags;
1371   pe_data (link_info.output_bfd)->insert_timestamp = insert_timestamp;
1372
1373   /* At this point we must decide whether to use long section names
1374      in the output or not.  If the user hasn't explicitly specified
1375      on the command line, we leave it to the default for the format
1376      (object files yes, image files no), except if there is debug
1377      information present; GDB relies on the long section names to
1378      find it, so enable it in that case.  */
1379   if (pe_use_coff_long_section_names < 0 && link_info.strip == strip_none)
1380     {
1381       if (bfd_link_relocatable (&link_info))
1382         pe_use_coff_long_section_names = 1;
1383       else
1384         {
1385           /* Iterate over all sections of all input BFDs, checking
1386              for any that begin 'debug_' and are long names.  */
1387           LANG_FOR_EACH_INPUT_STATEMENT (is)
1388           {
1389             int found_debug = 0;
1390
1391             bfd_map_over_sections (is->the_bfd, debug_section_p, &found_debug);
1392             if (found_debug)
1393               {
1394                 pe_use_coff_long_section_names = 1;
1395                 break;
1396               }
1397           }
1398         }
1399     }
1400
1401   pe_output_file_set_long_section_names (link_info.output_bfd);
1402
1403 #ifdef DLL_SUPPORT
1404   pe_process_import_defs (link_info.output_bfd, &link_info);
1405
1406   if (link_info.pei386_auto_import) /* -1=warn or 1=enable */
1407     pe_find_data_imports (U ("_head_"), make_import_fixup);
1408
1409   /* The implementation of the feature is rather dumb and would cause the
1410      compilation time to go through the roof if there are many undefined
1411      symbols in the link, so it needs to be run after auto-import.  */
1412   if (pe_enable_stdcall_fixup) /* -1=warn or 1=enable */
1413     pe_fixup_stdcalls ();
1414
1415 #if defined (TARGET_IS_i386pe) \
1416     || defined (TARGET_IS_armpe) \
1417     || defined (TARGET_IS_arm_wince_pe)
1418   if (!bfd_link_relocatable (&link_info))
1419     pe_dll_build_sections (link_info.output_bfd, &link_info);
1420 #else
1421   if (bfd_link_pic (&link_info))
1422     pe_dll_build_sections (link_info.output_bfd, &link_info);
1423   else
1424     pe_exe_build_sections (link_info.output_bfd, &link_info);
1425 #endif
1426 #endif /* DLL_SUPPORT */
1427
1428 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_wince_pe)
1429   if (strstr (bfd_get_target (link_info.output_bfd), "arm") == NULL)
1430     {
1431       /* The arm backend needs special fields in the output hash structure.
1432          These will only be created if the output format is an arm format,
1433          hence we do not support linking and changing output formats at the
1434          same time.  Use a link followed by objcopy to change output formats.  */
1435       einfo (_("%F%P: error: cannot change output format "
1436                "whilst linking %s binaries\n"), "ARM");
1437       return;
1438     }
1439   {
1440     /* Find a BFD that can hold the interworking stubs.  */
1441     LANG_FOR_EACH_INPUT_STATEMENT (is)
1442       {
1443         if (bfd_arm_get_bfd_for_interworking (is->the_bfd, & link_info))
1444           break;
1445       }
1446   }
1447 #endif
1448
1449   {
1450     /* This next chunk of code tries to detect the case where you have
1451        two import libraries for the same DLL (specifically,
1452        symbolically linking libm.a and libc.a in cygwin to
1453        libcygwin.a).  In those cases, it's possible for function
1454        thunks from the second implib to be used but without the
1455        head/tail objects, causing an improper import table.  We detect
1456        those cases and rename the "other" import libraries to match
1457        the one the head/tail come from, so that the linker will sort
1458        things nicely and produce a valid import table.  */
1459
1460     LANG_FOR_EACH_INPUT_STATEMENT (is)
1461       {
1462         if (is->the_bfd->my_archive)
1463           {
1464             int idata2 = 0, reloc_count=0, is_imp = 0;
1465             asection *sec;
1466
1467             /* See if this is an import library thunk.  */
1468             for (sec = is->the_bfd->sections; sec; sec = sec->next)
1469               {
1470                 if (strcmp (sec->name, ".idata\$2") == 0)
1471                   idata2 = 1;
1472                 if (CONST_STRNEQ (sec->name, ".idata\$"))
1473                   is_imp = 1;
1474                 reloc_count += sec->reloc_count;
1475               }
1476
1477             if (is_imp && !idata2 && reloc_count)
1478               {
1479                 /* It is, look for the reference to head and see if it's
1480                    from our own library.  */
1481                 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1482                   {
1483                     int i;
1484                     long relsize;
1485                     asymbol **symbols;
1486                     arelent **relocs;
1487                     int nrelocs;
1488
1489                     relsize = bfd_get_reloc_upper_bound (is->the_bfd, sec);
1490                     if (relsize < 1)
1491                       break;
1492
1493                     if (!bfd_generic_link_read_symbols (is->the_bfd))
1494                       {
1495                         einfo (_("%F%P: %pB: could not read symbols: %E\n"),
1496                                is->the_bfd);
1497                         return;
1498                       }
1499                     symbols = bfd_get_outsymbols (is->the_bfd);
1500
1501                     relocs = xmalloc ((size_t) relsize);
1502                     nrelocs = bfd_canonicalize_reloc (is->the_bfd, sec,
1503                                                       relocs, symbols);
1504                     if (nrelocs < 0)
1505                       {
1506                         free (relocs);
1507                         einfo (_("%X%P: unable to process relocs: %E\n"));
1508                         return;
1509                       }
1510
1511                     for (i = 0; i < nrelocs; i++)
1512                       {
1513                         struct bfd_symbol *s;
1514                         struct bfd_link_hash_entry * blhe;
1515                         char *other_bfd_filename;
1516                         char *n;
1517
1518                         s = (relocs[i]->sym_ptr_ptr)[0];
1519
1520                         if (s->flags & BSF_LOCAL)
1521                           continue;
1522
1523                         /* Thunk section with reloc to another bfd.  */
1524                         blhe = bfd_link_hash_lookup (link_info.hash,
1525                                                      s->name,
1526                                                      FALSE, FALSE, TRUE);
1527
1528                         if (blhe == NULL
1529                             || blhe->type != bfd_link_hash_defined)
1530                           continue;
1531
1532                         other_bfd_filename
1533                           = blhe->u.def.section->owner->my_archive
1534                             ? bfd_get_filename (blhe->u.def.section->owner->my_archive)
1535                             : bfd_get_filename (blhe->u.def.section->owner);
1536
1537                         if (filename_cmp (bfd_get_filename
1538                                             (is->the_bfd->my_archive),
1539                                           other_bfd_filename) == 0)
1540                           continue;
1541
1542                         /* Rename this implib to match the other one.  */
1543                         n = xmalloc (strlen (other_bfd_filename) + 1);
1544                         strcpy (n, other_bfd_filename);
1545                         is->the_bfd->my_archive->filename = n;
1546                       }
1547
1548                     free (relocs);
1549                     /* Note - we do not free the symbols,
1550                        they are now cached in the BFD.  */
1551                   }
1552               }
1553           }
1554       }
1555   }
1556
1557   {
1558     int is_ms_arch = 0;
1559     bfd *cur_arch = 0;
1560     lang_input_statement_type *is2;
1561     lang_input_statement_type *is3;
1562
1563     /* Careful - this is a shell script.  Watch those dollar signs! */
1564     /* Microsoft import libraries have every member named the same,
1565        and not in the right order for us to link them correctly.  We
1566        must detect these and rename the members so that they'll link
1567        correctly.  There are three types of objects: the head, the
1568        thunks, and the sentinel(s).  The head is easy; it's the one
1569        with idata2.  We assume that the sentinels won't have relocs,
1570        and the thunks will.  It's easier than checking the symbol
1571        table for external references.  */
1572     LANG_FOR_EACH_INPUT_STATEMENT (is)
1573       {
1574         if (is->the_bfd->my_archive)
1575           {
1576             char *pnt;
1577             bfd *arch = is->the_bfd->my_archive;
1578
1579             if (cur_arch != arch)
1580               {
1581                 cur_arch = arch;
1582                 is_ms_arch = 1;
1583
1584                 for (is3 = is;
1585                      is3 && is3->the_bfd->my_archive == arch;
1586                      is3 = (lang_input_statement_type *) is3->next)
1587                   {
1588                     /* A MS dynamic import library can also contain static
1589                        members, so look for the first element with a .dll
1590                        extension, and use that for the remainder of the
1591                        comparisons.  */
1592                     pnt = strrchr (is3->the_bfd->filename, '.');
1593                     if (pnt != NULL && filename_cmp (pnt, ".dll") == 0)
1594                       break;
1595                   }
1596
1597                 if (is3 == NULL)
1598                   is_ms_arch = 0;
1599                 else
1600                   {
1601                     /* OK, found one.  Now look to see if the remaining
1602                        (dynamic import) members use the same name.  */
1603                     for (is2 = is;
1604                          is2 && is2->the_bfd->my_archive == arch;
1605                          is2 = (lang_input_statement_type *) is2->next)
1606                       {
1607                         /* Skip static members, ie anything with a .obj
1608                            extension.  */
1609                         pnt = strrchr (is2->the_bfd->filename, '.');
1610                         if (pnt != NULL && filename_cmp (pnt, ".obj") == 0)
1611                           continue;
1612
1613                         if (filename_cmp (is3->the_bfd->filename,
1614                                           is2->the_bfd->filename))
1615                           {
1616                             is_ms_arch = 0;
1617                             break;
1618                           }
1619                       }
1620                   }
1621               }
1622
1623             /* This fragment might have come from an .obj file in a Microsoft
1624                import, and not an actual import record. If this is the case,
1625                then leave the filename alone.  */
1626             pnt = strrchr (is->the_bfd->filename, '.');
1627
1628             if (is_ms_arch && (filename_cmp (pnt, ".dll") == 0))
1629               {
1630                 int idata2 = 0, reloc_count=0;
1631                 asection *sec;
1632                 char *new_name, seq;
1633
1634                 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1635                   {
1636                     if (strcmp (sec->name, ".idata\$2") == 0)
1637                       idata2 = 1;
1638                     reloc_count += sec->reloc_count;
1639                   }
1640
1641                 if (idata2) /* .idata2 is the TOC */
1642                   seq = 'a';
1643                 else if (reloc_count > 0) /* thunks */
1644                   seq = 'b';
1645                 else /* sentinel */
1646                   seq = 'c';
1647
1648                 new_name = xmalloc (strlen (is->the_bfd->filename) + 3);
1649                 sprintf (new_name, "%s.%c", is->the_bfd->filename, seq);
1650                 is->the_bfd->filename = new_name;
1651
1652                 new_name = xmalloc (strlen (is->filename) + 3);
1653                 sprintf (new_name, "%s.%c", is->filename, seq);
1654                 is->filename = new_name;
1655               }
1656           }
1657       }
1658   }
1659
1660   {
1661     /* The following chunk of code tries to identify jump stubs in
1662        import libraries which are dead code and eliminates them
1663        from the final link. For each exported symbol <sym>, there
1664        is a object file in the import library with a .text section
1665        and several .idata\$* sections. The .text section contains the
1666        symbol definition for <sym> which is a jump stub of the form
1667        jmp *__imp_<sym>. The .idata\$5 contains the symbol definition
1668        for __imp_<sym> which is the address of the slot for <sym> in
1669        the import address table. When a symbol is imported explicitly
1670        using __declspec(dllimport) declaration, the compiler generates
1671        a reference to __imp_<sym> which directly resolves to the
1672        symbol in .idata\$5, in which case the jump stub code is not
1673        needed. The following code tries to identify jump stub sections
1674        in import libraries which are not referred to by anyone and
1675        marks them for exclusion from the final link.  */
1676     LANG_FOR_EACH_INPUT_STATEMENT (is)
1677       {
1678         if (is->the_bfd->my_archive)
1679           {
1680             int is_imp = 0;
1681             asection *sec, *stub_sec = NULL;
1682
1683             /* See if this is an import library thunk.  */
1684             for (sec = is->the_bfd->sections; sec; sec = sec->next)
1685               {
1686                 if (strncmp (sec->name, ".idata\$", 7) == 0)
1687                   is_imp = 1;
1688                 /* The section containing the jmp stub has code
1689                    and has a reloc.  */
1690                 if ((sec->flags & SEC_CODE) && sec->reloc_count)
1691                   stub_sec = sec;
1692               }
1693
1694             if (is_imp && stub_sec)
1695               {
1696                 asymbol **symbols;
1697                 long nsyms, src_count;
1698                 struct bfd_link_hash_entry * blhe;
1699
1700                 if (!bfd_generic_link_read_symbols (is->the_bfd))
1701                   {
1702                     einfo (_("%F%P: %pB: could not read symbols: %E\n"),
1703                            is->the_bfd);
1704                     return;
1705                   }
1706                 symbols = bfd_get_outsymbols (is->the_bfd);
1707                 nsyms = bfd_get_symcount (is->the_bfd);
1708
1709                 for (src_count = 0; src_count < nsyms; src_count++)
1710                   {
1711                     if (symbols[src_count]->section->id == stub_sec->id)
1712                       {
1713                         /* This symbol belongs to the section containing
1714                            the stub.  */
1715                         blhe = bfd_link_hash_lookup (link_info.hash,
1716                                                      symbols[src_count]->name,
1717                                                      FALSE, FALSE, TRUE);
1718                         /* If the symbol in the stub section has no other
1719                            undefined references, exclude the stub section
1720                            from the final link.  */
1721                         if (blhe != NULL
1722                             && blhe->type == bfd_link_hash_defined
1723                             && blhe->u.undef.next == NULL
1724                             && blhe != link_info.hash->undefs_tail)
1725                           stub_sec->flags |= SEC_EXCLUDE;
1726                       }
1727                   }
1728               }
1729           }
1730       }
1731   }
1732 }
1733 \f
1734 static void
1735 gld_${EMULATION_NAME}_before_allocation (void)
1736 {
1737 #ifdef TARGET_IS_ppcpe
1738   /* Here we rummage through the found bfds to collect toc information.  */
1739   {
1740     LANG_FOR_EACH_INPUT_STATEMENT (is)
1741       {
1742         if (!ppc_process_before_allocation (is->the_bfd, &link_info))
1743           {
1744             /* xgettext:c-format */
1745             einfo (_("%P: errors encountered processing file %s\n"), is->filename);
1746           }
1747       }
1748   }
1749
1750   /* We have seen it all. Allocate it, and carry on.  */
1751   ppc_allocate_toc_section (&link_info);
1752 #endif /* TARGET_IS_ppcpe */
1753
1754 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_wince_pe)
1755   /* FIXME: we should be able to set the size of the interworking stub
1756      section.
1757
1758      Here we rummage through the found bfds to collect glue
1759      information.  FIXME: should this be based on a command line
1760      option?  krk@cygnus.com.  */
1761   {
1762     LANG_FOR_EACH_INPUT_STATEMENT (is)
1763       {
1764         if (! bfd_arm_process_before_allocation
1765             (is->the_bfd, & link_info, support_old_code))
1766           {
1767             /* xgettext:c-format */
1768             einfo (_("%P: errors encountered processing file %s for interworking\n"),
1769                    is->filename);
1770           }
1771       }
1772   }
1773
1774   /* We have seen it all. Allocate it, and carry on.  */
1775   bfd_arm_allocate_interworking_sections (& link_info);
1776 #endif /* TARGET_IS_armpe || TARGET_IS_arm_wince_pe */
1777
1778   before_allocation_default ();
1779 }
1780 \f
1781 #ifdef DLL_SUPPORT
1782 /* This is called when an input file isn't recognized as a BFD.  We
1783    check here for .DEF files and pull them in automatically.  */
1784
1785 static int
1786 saw_option (char *option)
1787 {
1788   int i;
1789
1790   for (i = 0; init[i].ptr; i++)
1791     if (strcmp (GET_INIT_SYMBOL_NAME (i), option) == 0)
1792       return init[i].inited;
1793   return 0;
1794 }
1795 #endif /* DLL_SUPPORT */
1796
1797 static bfd_boolean
1798 gld_${EMULATION_NAME}_unrecognized_file (lang_input_statement_type *entry ATTRIBUTE_UNUSED)
1799 {
1800 #ifdef DLL_SUPPORT
1801   const char *ext = entry->filename + strlen (entry->filename) - 4;
1802
1803   if (filename_cmp (ext, ".def") == 0 || filename_cmp (ext, ".DEF") == 0)
1804     {
1805       pe_def_file = def_file_parse (entry->filename, pe_def_file);
1806
1807       if (pe_def_file)
1808         {
1809           int i, buflen=0, len;
1810           char *buf;
1811
1812           for (i = 0; i < pe_def_file->num_exports; i++)
1813             {
1814               len = strlen (pe_def_file->exports[i].internal_name);
1815               if (buflen < len + 2)
1816                 buflen = len + 2;
1817             }
1818
1819           buf = xmalloc (buflen);
1820
1821           for (i = 0; i < pe_def_file->num_exports; i++)
1822             {
1823               struct bfd_link_hash_entry *h;
1824
1825               sprintf (buf, "%s%s", U (""),
1826                        pe_def_file->exports[i].internal_name);
1827
1828               h = bfd_link_hash_lookup (link_info.hash, buf, TRUE, TRUE, TRUE);
1829               if (h == (struct bfd_link_hash_entry *) NULL)
1830                 einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
1831               if (h->type == bfd_link_hash_new)
1832                 {
1833                   h->type = bfd_link_hash_undefined;
1834                   h->u.undef.abfd = NULL;
1835                   bfd_link_add_undef (link_info.hash, h);
1836                 }
1837             }
1838           free (buf);
1839
1840           /* def_file_print (stdout, pe_def_file); */
1841           if (pe_def_file->is_dll == 1)
1842             link_info.type = type_dll;
1843
1844           if (pe_def_file->base_address != (bfd_vma)(-1))
1845             {
1846               pe.ImageBase
1847                 = pe_data (link_info.output_bfd)->pe_opthdr.ImageBase
1848                 = init[IMAGEBASEOFF].value
1849                 = pe_def_file->base_address;
1850               init[IMAGEBASEOFF].inited = 1;
1851               if (image_base_statement)
1852                 image_base_statement->exp
1853                   = exp_assign ("__image_base__", exp_intop (pe.ImageBase),
1854                                 FALSE);
1855             }
1856
1857           if (pe_def_file->stack_reserve != -1
1858               && ! saw_option ("__size_of_stack_reserve__"))
1859             {
1860               pe.SizeOfStackReserve = pe_def_file->stack_reserve;
1861               if (pe_def_file->stack_commit != -1)
1862                 pe.SizeOfStackCommit = pe_def_file->stack_commit;
1863             }
1864           if (pe_def_file->heap_reserve != -1
1865               && ! saw_option ("__size_of_heap_reserve__"))
1866             {
1867               pe.SizeOfHeapReserve = pe_def_file->heap_reserve;
1868               if (pe_def_file->heap_commit != -1)
1869                 pe.SizeOfHeapCommit = pe_def_file->heap_commit;
1870             }
1871           return TRUE;
1872         }
1873     }
1874 #endif
1875   return FALSE;
1876 }
1877
1878 static bfd_boolean
1879 gld_${EMULATION_NAME}_recognized_file (lang_input_statement_type *entry ATTRIBUTE_UNUSED)
1880 {
1881 #ifdef DLL_SUPPORT
1882 #ifdef TARGET_IS_i386pe
1883   pe_dll_id_target ("pei-i386");
1884 #endif
1885 #ifdef TARGET_IS_shpe
1886   pe_dll_id_target ("pei-shl");
1887 #endif
1888 #ifdef TARGET_IS_armpe
1889   pe_dll_id_target ("pei-arm-little");
1890 #endif
1891 #ifdef TARGET_IS_arm_wince_pe
1892   pe_dll_id_target ("pei-arm-wince-little");
1893 #endif
1894   if (pe_bfd_is_dll (entry->the_bfd))
1895     return pe_implied_import_dll (entry->filename);
1896 #endif
1897   return FALSE;
1898 }
1899
1900 static void
1901 gld_${EMULATION_NAME}_finish (void)
1902 {
1903 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_wince_pe)
1904   struct bfd_link_hash_entry * h;
1905
1906   if (thumb_entry_symbol != NULL)
1907     {
1908       h = bfd_link_hash_lookup (link_info.hash, thumb_entry_symbol,
1909                                 FALSE, FALSE, TRUE);
1910
1911       if (h != (struct bfd_link_hash_entry *) NULL
1912           && (h->type == bfd_link_hash_defined
1913               || h->type == bfd_link_hash_defweak)
1914           && h->u.def.section->output_section != NULL)
1915         {
1916           static char buffer[32];
1917           bfd_vma val;
1918
1919           /* Special procesing is required for a Thumb entry symbol.  The
1920              bottom bit of its address must be set.  */
1921           val = (h->u.def.value
1922                  + bfd_get_section_vma (link_info.output_bfd,
1923                                         h->u.def.section->output_section)
1924                  + h->u.def.section->output_offset);
1925
1926           val |= 1;
1927
1928           /* Now convert this value into a string and store it in entry_symbol
1929              where the lang_finish() function will pick it up.  */
1930           buffer[0] = '0';
1931           buffer[1] = 'x';
1932
1933           sprintf_vma (buffer + 2, val);
1934
1935           if (entry_symbol.name != NULL && entry_from_cmdline)
1936             einfo (_("%P: warning: '--thumb-entry %s' is overriding '-e %s'\n"),
1937                    thumb_entry_symbol, entry_symbol.name);
1938           entry_symbol.name = buffer;
1939         }
1940       else
1941         einfo (_("%P: warning: cannot find thumb start symbol %s\n"), thumb_entry_symbol);
1942     }
1943 #endif /* defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_wince_pe) */
1944
1945   finish_default ();
1946
1947 #ifdef DLL_SUPPORT
1948   if (bfd_link_pic (&link_info)
1949 #if !defined(TARGET_IS_shpe)
1950       || (!bfd_link_relocatable (&link_info)
1951           && pe_def_file->num_exports != 0)
1952 #endif
1953     )
1954     {
1955       pe_dll_fill_sections (link_info.output_bfd, &link_info);
1956       if (command_line.out_implib_filename)
1957         pe_dll_generate_implib (pe_def_file, command_line.out_implib_filename,
1958                                 &link_info);
1959     }
1960 #if defined(TARGET_IS_shpe)
1961   /* ARM doesn't need relocs.  */
1962   else
1963     {
1964       pe_exe_fill_sections (link_info.output_bfd, &link_info);
1965     }
1966 #endif
1967
1968   if (pe_out_def_filename)
1969     pe_dll_generate_def_file (pe_out_def_filename);
1970 #endif /* DLL_SUPPORT */
1971
1972   /* I don't know where .idata gets set as code, but it shouldn't be.  */
1973   {
1974     asection *asec = bfd_get_section_by_name (link_info.output_bfd, ".idata");
1975
1976     if (asec)
1977       {
1978         asec->flags &= ~SEC_CODE;
1979         asec->flags |= SEC_DATA;
1980       }
1981   }
1982 }
1983
1984 \f
1985 /* Place an orphan section.
1986
1987    We use this to put sections in a reasonable place in the file, and
1988    to ensure that they are aligned as required.
1989
1990    We handle grouped sections here as well.  A section named .foo\$nn
1991    goes into the output section .foo.  All grouped sections are sorted
1992    by name.
1993
1994    Grouped sections for the default sections are handled by the
1995    default linker script using wildcards, and are sorted by
1996    sort_sections.  */
1997
1998 static lang_output_section_statement_type *
1999 gld_${EMULATION_NAME}_place_orphan (asection *s,
2000                                     const char *secname,
2001                                     int constraint)
2002 {
2003   const char *orig_secname = secname;
2004   char *dollar = NULL;
2005   lang_output_section_statement_type *os;
2006   lang_statement_list_type add_child;
2007   lang_output_section_statement_type *match_by_name = NULL;
2008   lang_statement_union_type **pl;
2009
2010   /* Look through the script to see where to place this section.  */
2011   if (!bfd_link_relocatable (&link_info)
2012       && (dollar = strchr (secname, '\$')) != NULL)
2013     {
2014       size_t len = dollar - secname;
2015       char *newname = xmalloc (len + 1);
2016       memcpy (newname, secname, len);
2017       newname[len] = '\0';
2018       secname = newname;
2019     }
2020
2021   lang_list_init (&add_child);
2022
2023   os = NULL;
2024   if (constraint == 0)
2025     for (os = lang_output_section_find (secname);
2026          os != NULL;
2027          os = next_matching_output_section_statement (os, 0))
2028       {
2029         /* If we don't match an existing output section, tell
2030            lang_insert_orphan to create a new output section.  */
2031         constraint = SPECIAL;
2032
2033         if (os->bfd_section != NULL
2034             && (os->bfd_section->flags == 0
2035                 || ((s->flags ^ os->bfd_section->flags)
2036                     & (SEC_LOAD | SEC_ALLOC)) == 0))
2037           {
2038             /* We already have an output section statement with this
2039                name, and its bfd section has compatible flags.
2040                If the section already exists but does not have any flags set,
2041                then it has been created by the linker, probably as a result of
2042                a --section-start command line switch.  */
2043             lang_add_section (&add_child, s, NULL, os);
2044             break;
2045           }
2046
2047         /* Save unused output sections in case we can match them
2048            against orphans later.  */
2049         if (os->bfd_section == NULL)
2050           match_by_name = os;
2051       }
2052
2053   /* If we didn't match an active output section, see if we matched an
2054      unused one and use that.  */
2055   if (os == NULL && match_by_name)
2056     {
2057       lang_add_section (&match_by_name->children, s, NULL, match_by_name);
2058       return match_by_name;
2059     }
2060
2061   if (os == NULL)
2062     {
2063       static struct orphan_save hold[] =
2064         {
2065           { ".text",
2066             SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE,
2067             0, 0, 0, 0 },
2068           { ".idata",
2069             SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
2070             0, 0, 0, 0 },
2071           { ".rdata",
2072             SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA,
2073             0, 0, 0, 0 },
2074           { ".data",
2075             SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_DATA,
2076             0, 0, 0, 0 },
2077           { ".bss",
2078             SEC_ALLOC,
2079             0, 0, 0, 0 }
2080         };
2081       enum orphan_save_index
2082         {
2083           orphan_text = 0,
2084           orphan_idata,
2085           orphan_rodata,
2086           orphan_data,
2087           orphan_bss
2088         };
2089       static int orphan_init_done = 0;
2090       struct orphan_save *place;
2091       lang_output_section_statement_type *after;
2092       etree_type *address;
2093       flagword flags;
2094       asection *nexts;
2095
2096       if (!orphan_init_done)
2097         {
2098           struct orphan_save *ho;
2099           for (ho = hold; ho < hold + sizeof (hold) / sizeof (hold[0]); ++ho)
2100             if (ho->name != NULL)
2101               {
2102                 ho->os = lang_output_section_find (ho->name);
2103                 if (ho->os != NULL && ho->os->flags == 0)
2104                   ho->os->flags = ho->flags;
2105               }
2106           orphan_init_done = 1;
2107         }
2108
2109       flags = s->flags;
2110       if (!bfd_link_relocatable (&link_info))
2111         {
2112           nexts = s;
2113           while ((nexts = bfd_get_next_section_by_name (nexts->owner,
2114                                                         nexts)))
2115             if (nexts->output_section == NULL
2116                 && (nexts->flags & SEC_EXCLUDE) == 0
2117                 && ((nexts->flags ^ flags) & (SEC_LOAD | SEC_ALLOC)) == 0
2118                 && (nexts->owner->flags & DYNAMIC) == 0
2119                 && nexts->owner->usrdata != NULL
2120                 && !(((lang_input_statement_type *) nexts->owner->usrdata)
2121                      ->flags.just_syms))
2122               flags = (((flags ^ SEC_READONLY)
2123                         | (nexts->flags ^ SEC_READONLY))
2124                        ^ SEC_READONLY);
2125         }
2126
2127       /* Try to put the new output section in a reasonable place based
2128          on the section name and section flags.  */
2129
2130       place = NULL;
2131       if ((flags & SEC_ALLOC) == 0)
2132         ;
2133       else if ((flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2134         place = &hold[orphan_bss];
2135       else if ((flags & SEC_READONLY) == 0)
2136         place = &hold[orphan_data];
2137       else if ((flags & SEC_CODE) == 0)
2138         {
2139           place = (!strncmp (secname, ".idata\$", 7) ? &hold[orphan_idata]
2140                                                      : &hold[orphan_rodata]);
2141         }
2142       else
2143         place = &hold[orphan_text];
2144
2145       after = NULL;
2146       if (place != NULL)
2147         {
2148           if (place->os == NULL)
2149             place->os = lang_output_section_find (place->name);
2150           after = place->os;
2151           if (after == NULL)
2152             after = lang_output_section_find_by_flags (s, flags, &place->os,
2153                                                        NULL);
2154           if (after == NULL)
2155             /* *ABS* is always the first output section statement.  */
2156             after = (&lang_output_section_statement.head
2157                      ->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