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