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