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