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