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