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