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