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, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
  12    2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
  13
  14    This file is part of the GNU Binutils.
  15
  16    This program is free software; you can redistribute it and/or modify
  17    it under the terms of the GNU General Public License as published by
  18    the Free Software Foundation; either version 3 of the License, or
  19    (at your option) any later version.
  20
  21    This program is distributed in the hope that it will be useful,
  22    but WITHOUT ANY WARRANTY; without even the implied warranty of
  23    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24    GNU General Public License for more details.
  25
  26    You should have received a copy of the GNU General Public License
  27    along with this program; if not, write to the Free Software
  28    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  29    MA 02110-1301, USA.  */
  30
  31
  32 /* For WINDOWS_NT */
  33 /* The original file generated returned different default scripts depending
  34    on whether certain switches were set, but these switches pertain to the
  35    Linux system and that particular version of coff.  In the NT case, we
  36    only determine if the subsystem is console or windows in order to select
  37    the correct entry point by default. */
  38
  39 #define TARGET_IS_${EMULATION_NAME}
  40
  41 /* Do this before including bfd.h, so we prototype the right functions.  */
  42
  43 #if defined(TARGET_IS_armpe) \
  44     || defined(TARGET_IS_arm_epoc_pe) \
  45     || defined(TARGET_IS_arm_wince_pe)
  46 #define bfd_arm_allocate_interworking_sections \
  47         bfd_${EMULATION_NAME}_allocate_interworking_sections
  48 #define bfd_arm_get_bfd_for_interworking \
  49         bfd_${EMULATION_NAME}_get_bfd_for_interworking
  50 #define bfd_arm_process_before_allocation \
  51         bfd_${EMULATION_NAME}_process_before_allocation
  52 #endif
  53
  54 #include "sysdep.h"
  55 #include "bfd.h"
  56 #include "bfdlink.h"
  57 #include "getopt.h"
  58 #include "libiberty.h"
  59 #include "filenames.h"
  60 #include "ld.h"
  61 #include "ldmain.h"
  62 #include "ldexp.h"
  63 #include "ldlang.h"
  64 #include "ldfile.h"
  65 #include "ldemul.h"
  66 #include <ldgram.h>
  67 #include "ldlex.h"
  68 #include "ldmisc.h"
  69 #include "ldctor.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: This is a BFD internal header file, and we should not be
  78    using it here.  */
  79 #include "../bfd/libcoff.h"
  80
  81 #include "deffile.h"
  82 #include "pe-dll.h"
  83 #include "safe-ctype.h"
  84
  85 /* Permit the emulation parameters to override the default section
  86    alignment by setting OVERRIDE_SECTION_ALIGNMENT.  FIXME: This makes
  87    it seem that include/coff/internal.h should not define
  88    PE_DEF_SECTION_ALIGNMENT.  */
  89 #if PE_DEF_SECTION_ALIGNMENT != ${OVERRIDE_SECTION_ALIGNMENT:-PE_DEF_SECTION_ALIGNMENT}
  90 #undef PE_DEF_SECTION_ALIGNMENT
  91 #define PE_DEF_SECTION_ALIGNMENT ${OVERRIDE_SECTION_ALIGNMENT}
  92 #endif
  93
  94 #if defined(TARGET_IS_i386pe) \
  95     || defined(TARGET_IS_shpe) \
  96     || defined(TARGET_IS_mipspe) \
  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
 136 #ifdef DLL_SUPPORT
 137 static int pe_enable_stdcall_fixup = -1; /* 0=disable 1=enable.  */
 138 static char *pe_out_def_filename = NULL;
 139 static char *pe_implib_filename = NULL;
 140 static int pe_enable_auto_image_base = 0;
 141 static char *pe_dll_search_prefix = NULL;
 142 #endif
 143
 144 extern const char *output_filename;
 145
 146 static int is_underscoring (void)
 147 {
 148   int u = 0;
 149   if (pe_leading_underscore != -1)
 150     return pe_leading_underscore;
 151   if (!bfd_get_target_info ("${OUTPUT_FORMAT}", NULL, NULL, &u, NULL))
 152     bfd_get_target_info ("${RELOCATEABLE_OUTPUT_FORMAT}", NULL, NULL, &u, NULL);
 153
 154   if (u == -1)
 155     abort ();
 156   pe_leading_underscore = (u != 0 ? 1 : 0);
 157   return pe_leading_underscore;
 158 }
 159
 160 static void
 161 gld_${EMULATION_NAME}_before_parse (void)
 162 {
 163   is_underscoring ();
 164   ldfile_set_output_arch ("${OUTPUT_ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`);
 165   output_filename = "${EXECUTABLE_NAME:-a.exe}";
 166 #ifdef DLL_SUPPORT
 167   config.dynamic_link = TRUE;
 168   config.has_shared = 1;
 169 EOF
 170
 171 # Cygwin no longer wants these noisy warnings.  Other PE
 172 # targets might like to consider adding themselves here.
 173 case ${target} in
 174   *-*-cygwin*)
 175     default_auto_import=1
 176     default_merge_rdata=1
 177     ;;
 178   i[3-7]86-*-mingw* | x86_64-*-mingw*)
 179     default_auto_import=1
 180     default_merge_rdata=0
 181     ;;
 182   *)
 183     default_auto_import=-1
 184     default_merge_rdata=1
 185     ;;
 186 esac
 187
 188 fragment <<EOF
 189   link_info.pei386_auto_import = ${default_auto_import};
 190   /* Use by default version.  */
 191   link_info.pei386_runtime_pseudo_reloc = DEFAULT_PSEUDO_RELOC_VERSION;
 192 #endif
 193 }
 194 \f
 195 /* Indicates if RDATA shall be merged into DATA when pseudo-relocation
 196    version 2 is used and auto-import is enabled.  */
 197 #define MERGE_RDATA_V2 ${default_merge_rdata}
 198
 199 /* PE format extra command line options.  */
 200
 201 /* Used for setting flags in the PE header.  */
 202 #define OPTION_BASE_FILE                (300  + 1)
 203 #define OPTION_DLL                      (OPTION_BASE_FILE + 1)
 204 #define OPTION_FILE_ALIGNMENT           (OPTION_DLL + 1)
 205 #define OPTION_IMAGE_BASE               (OPTION_FILE_ALIGNMENT + 1)
 206 #define OPTION_MAJOR_IMAGE_VERSION      (OPTION_IMAGE_BASE + 1)
 207 #define OPTION_MAJOR_OS_VERSION         (OPTION_MAJOR_IMAGE_VERSION + 1)
 208 #define OPTION_MAJOR_SUBSYSTEM_VERSION  (OPTION_MAJOR_OS_VERSION + 1)
 209 #define OPTION_MINOR_IMAGE_VERSION      (OPTION_MAJOR_SUBSYSTEM_VERSION + 1)
 210 #define OPTION_MINOR_OS_VERSION         (OPTION_MINOR_IMAGE_VERSION + 1)
 211 #define OPTION_MINOR_SUBSYSTEM_VERSION  (OPTION_MINOR_OS_VERSION + 1)
 212 #define OPTION_SECTION_ALIGNMENT        (OPTION_MINOR_SUBSYSTEM_VERSION + 1)
 213 #define OPTION_STACK                    (OPTION_SECTION_ALIGNMENT + 1)
 214 #define OPTION_SUBSYSTEM                (OPTION_STACK + 1)
 215 #define OPTION_HEAP                     (OPTION_SUBSYSTEM + 1)
 216 #define OPTION_SUPPORT_OLD_CODE         (OPTION_HEAP + 1)
 217 #define OPTION_OUT_DEF                  (OPTION_SUPPORT_OLD_CODE + 1)
 218 #define OPTION_EXPORT_ALL               (OPTION_OUT_DEF + 1)
 219 #define OPTION_EXCLUDE_SYMBOLS          (OPTION_EXPORT_ALL + 1)
 220 #define OPTION_EXCLUDE_ALL_SYMBOLS      (OPTION_EXCLUDE_SYMBOLS + 1)
 221 #define OPTION_KILL_ATS                 (OPTION_EXCLUDE_ALL_SYMBOLS + 1)
 222 #define OPTION_STDCALL_ALIASES          (OPTION_KILL_ATS + 1)
 223 #define OPTION_ENABLE_STDCALL_FIXUP     (OPTION_STDCALL_ALIASES + 1)
 224 #define OPTION_DISABLE_STDCALL_FIXUP    (OPTION_ENABLE_STDCALL_FIXUP + 1)
 225 #define OPTION_IMPLIB_FILENAME          (OPTION_DISABLE_STDCALL_FIXUP + 1)
 226 #define OPTION_THUMB_ENTRY              (OPTION_IMPLIB_FILENAME + 1)
 227 #define OPTION_WARN_DUPLICATE_EXPORTS   (OPTION_THUMB_ENTRY + 1)
 228 #define OPTION_IMP_COMPAT               (OPTION_WARN_DUPLICATE_EXPORTS + 1)
 229 #define OPTION_ENABLE_AUTO_IMAGE_BASE   (OPTION_IMP_COMPAT + 1)
 230 #define OPTION_DISABLE_AUTO_IMAGE_BASE  (OPTION_ENABLE_AUTO_IMAGE_BASE + 1)
 231 #define OPTION_DLL_SEARCH_PREFIX        (OPTION_DISABLE_AUTO_IMAGE_BASE + 1)
 232 #define OPTION_NO_DEFAULT_EXCLUDES      (OPTION_DLL_SEARCH_PREFIX + 1)
 233 #define OPTION_DLL_ENABLE_AUTO_IMPORT   (OPTION_NO_DEFAULT_EXCLUDES + 1)
 234 #define OPTION_DLL_DISABLE_AUTO_IMPORT  (OPTION_DLL_ENABLE_AUTO_IMPORT + 1)
 235 #define OPTION_ENABLE_EXTRA_PE_DEBUG    (OPTION_DLL_DISABLE_AUTO_IMPORT + 1)
 236 #define OPTION_EXCLUDE_LIBS             (OPTION_ENABLE_EXTRA_PE_DEBUG + 1)
 237 #define OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC  \
 238                                         (OPTION_EXCLUDE_LIBS + 1)
 239 #define OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC \
 240                                         (OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC + 1)
 241 #define OPTION_LARGE_ADDRESS_AWARE \
 242                                         (OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC + 1)
 243 #define OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V1       \
 244                                         (OPTION_LARGE_ADDRESS_AWARE + 1)
 245 #define OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V2       \
 246                                         (OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V1 + 1)
 247 #define OPTION_EXCLUDE_MODULES_FOR_IMPLIB \
 248                                         (OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V2 + 1)
 249 #define OPTION_USE_NUL_PREFIXED_IMPORT_TABLES \
 250                                         (OPTION_EXCLUDE_MODULES_FOR_IMPLIB + 1)
 251 #define OPTION_NO_LEADING_UNDERSCORE \
 252                                         (OPTION_USE_NUL_PREFIXED_IMPORT_TABLES + 1)
 253 #define OPTION_LEADING_UNDERSCORE \
 254                                         (OPTION_NO_LEADING_UNDERSCORE + 1)
 255 #define OPTION_ENABLE_LONG_SECTION_NAMES \
 256                                         (OPTION_LEADING_UNDERSCORE + 1)
 257 #define OPTION_DISABLE_LONG_SECTION_NAMES \
 258                                         (OPTION_ENABLE_LONG_SECTION_NAMES + 1)
 259 /* DLLCharacteristics flags */
 260 #define OPTION_DYNAMIC_BASE             (OPTION_DISABLE_LONG_SECTION_NAMES + 1)
 261 #define OPTION_FORCE_INTEGRITY          (OPTION_DYNAMIC_BASE + 1)
 262 #define OPTION_NX_COMPAT                (OPTION_FORCE_INTEGRITY + 1)
 263 #define OPTION_NO_ISOLATION             (OPTION_NX_COMPAT + 1)
 264 #define OPTION_NO_SEH                   (OPTION_NO_ISOLATION + 1)
 265 #define OPTION_NO_BIND                  (OPTION_NO_SEH + 1)
 266 #define OPTION_WDM_DRIVER               (OPTION_NO_BIND + 1)
 267 #define OPTION_TERMINAL_SERVER_AWARE    (OPTION_WDM_DRIVER + 1)
 268
 269 static void
 270 gld${EMULATION_NAME}_add_options
 271   (int ns ATTRIBUTE_UNUSED,
 272    char **shortopts ATTRIBUTE_UNUSED,
 273    int nl,
 274    struct option **longopts,
 275    int nrl ATTRIBUTE_UNUSED,
 276    struct option **really_longopts ATTRIBUTE_UNUSED)
 277 {
 278   static const struct option xtra_long[] = {
 279     /* PE options */
 280     {"base-file", required_argument, NULL, OPTION_BASE_FILE},
 281     {"dll", no_argument, NULL, OPTION_DLL},
 282     {"file-alignment", required_argument, NULL, OPTION_FILE_ALIGNMENT},
 283     {"heap", required_argument, NULL, OPTION_HEAP},
 284     {"image-base", required_argument, NULL, OPTION_IMAGE_BASE},
 285     {"major-image-version", required_argument, NULL, OPTION_MAJOR_IMAGE_VERSION},
 286     {"major-os-version", required_argument, NULL, OPTION_MAJOR_OS_VERSION},
 287     {"major-subsystem-version", required_argument, NULL, OPTION_MAJOR_SUBSYSTEM_VERSION},
 288     {"minor-image-version", required_argument, NULL, OPTION_MINOR_IMAGE_VERSION},
 289     {"minor-os-version", required_argument, NULL, OPTION_MINOR_OS_VERSION},
 290     {"minor-subsystem-version", required_argument, NULL, OPTION_MINOR_SUBSYSTEM_VERSION},
 291     {"section-alignment", required_argument, NULL, OPTION_SECTION_ALIGNMENT},
 292     {"stack", required_argument, NULL, OPTION_STACK},
 293     {"subsystem", required_argument, NULL, OPTION_SUBSYSTEM},
 294     {"support-old-code", no_argument, NULL, OPTION_SUPPORT_OLD_CODE},
 295     {"thumb-entry", required_argument, NULL, OPTION_THUMB_ENTRY},
 296     {"use-nul-prefixed-import-tables", no_argument, NULL,
 297      OPTION_USE_NUL_PREFIXED_IMPORT_TABLES},
 298     {"no-leading-underscore", no_argument, NULL, OPTION_NO_LEADING_UNDERSCORE},
 299     {"leading-underscore", no_argument, NULL, OPTION_LEADING_UNDERSCORE},
 300 #ifdef DLL_SUPPORT
 301     /* getopt allows abbreviations, so we do this to stop it
 302        from treating -o as an abbreviation for this option.  */
 303     {"output-def", required_argument, NULL, OPTION_OUT_DEF},
 304     {"output-def", required_argument, NULL, OPTION_OUT_DEF},
 305     {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL},
 306     {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMBOLS},
 307     {"exclude-all-symbols", no_argument, NULL, OPTION_EXCLUDE_ALL_SYMBOLS},
 308     {"exclude-libs", required_argument, NULL, OPTION_EXCLUDE_LIBS},
 309     {"exclude-modules-for-implib", required_argument, NULL, OPTION_EXCLUDE_MODULES_FOR_IMPLIB},
 310     {"kill-at", no_argument, NULL, OPTION_KILL_ATS},
 311     {"add-stdcall-alias", no_argument, NULL, OPTION_STDCALL_ALIASES},
 312     {"enable-stdcall-fixup", no_argument, NULL, OPTION_ENABLE_STDCALL_FIXUP},
 313     {"disable-stdcall-fixup", no_argument, NULL, OPTION_DISABLE_STDCALL_FIXUP},
 314     {"out-implib", required_argument, NULL, OPTION_IMPLIB_FILENAME},
 315     {"warn-duplicate-exports", no_argument, NULL, OPTION_WARN_DUPLICATE_EXPORTS},
 316     /* getopt() allows abbreviations, so we do this to stop it from
 317        treating -c as an abbreviation for these --compat-implib.  */
 318     {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT},
 319     {"compat-implib", no_argument, NULL, OPTION_IMP_COMPAT},
 320     {"enable-auto-image-base", no_argument, NULL, OPTION_ENABLE_AUTO_IMAGE_BASE},
 321     {"disable-auto-image-base", no_argument, NULL, OPTION_DISABLE_AUTO_IMAGE_BASE},
 322     {"dll-search-prefix", required_argument, NULL, OPTION_DLL_SEARCH_PREFIX},
 323     {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES},
 324     {"enable-auto-import", no_argument, NULL, OPTION_DLL_ENABLE_AUTO_IMPORT},
 325     {"disable-auto-import", no_argument, NULL, OPTION_DLL_DISABLE_AUTO_IMPORT},
 326     {"enable-extra-pe-debug", no_argument, NULL, OPTION_ENABLE_EXTRA_PE_DEBUG},
 327     {"enable-runtime-pseudo-reloc", no_argument, NULL, OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC},
 328     {"disable-runtime-pseudo-reloc", no_argument, NULL, OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC},
 329     {"enable-runtime-pseudo-reloc-v1", no_argument, NULL, OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V1},
 330     {"enable-runtime-pseudo-reloc-v2", no_argument, NULL, OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V2},
 331 #endif
 332     {"large-address-aware", no_argument, NULL, OPTION_LARGE_ADDRESS_AWARE},
 333     {"enable-long-section-names", no_argument, NULL, OPTION_ENABLE_LONG_SECTION_NAMES},
 334     {"disable-long-section-names", no_argument, NULL, OPTION_DISABLE_LONG_SECTION_NAMES},
 335     {"dynamicbase",no_argument, NULL, OPTION_DYNAMIC_BASE},
 336     {"forceinteg", no_argument, NULL, OPTION_FORCE_INTEGRITY},
 337     {"nxcompat", no_argument, NULL, OPTION_NX_COMPAT},
 338     {"no-isolation", no_argument, NULL, OPTION_NO_ISOLATION},
 339     {"no-seh", no_argument, NULL, OPTION_NO_SEH},
 340     {"no-bind", no_argument, NULL, OPTION_NO_BIND},
 341     {"wdmdriver", no_argument, NULL, OPTION_WDM_DRIVER},
 342     {"tsaware", no_argument, NULL, OPTION_TERMINAL_SERVER_AWARE},
 343     {NULL, no_argument, NULL, 0}
 344   };
 345
 346   *longopts
 347     = xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long));
 348   memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long));
 349 }
 350
 351 /* PE/WIN32; added routines to get the subsystem type, heap and/or stack
 352    parameters which may be input from the command line.  */
 353
 354 typedef struct
 355 {
 356   void *ptr;
 357   int size;
 358   int value;
 359   char *symbol;
 360   int inited;
 361   /* FALSE for an assembly level symbol and TRUE for a C visible symbol.
 362      C visible symbols can be prefixed by underscore dependent to target's
 363      settings.  */
 364   bfd_boolean is_c_symbol;
 365 } definfo;
 366
 367 /* Get symbol name dependent to kind and C visible state of
 368    underscore.  */
 369 #define GET_INIT_SYMBOL_NAME(IDX) \
 370   (init[(IDX)].symbol \
 371   + ((init[(IDX)].is_c_symbol == FALSE || (is_underscoring () != 0)) ? 0 : 1))
 372
 373 /* Decorates the C visible symbol by underscore, if target requires.  */
 374 #define U(CSTR) \
 375   ((is_underscoring () == 0) ? CSTR : "_" CSTR)
 376
 377 /* Get size of constant string for a possible underscore prefixed
 378    C visible symbol.  */
 379 #define U_SIZE(CSTR) \
 380   (sizeof (CSTR) + (is_underscoring () == 0 ? 0 : 1))
 381
 382 #define D(field,symbol,def,usc)  {&pe.field,sizeof(pe.field), def, symbol, 0, usc}
 383
 384 static definfo init[] =
 385 {
 386   /* imagebase must be first */
 387 #define IMAGEBASEOFF 0
 388   D(ImageBase,"__image_base__", NT_EXE_IMAGE_BASE, FALSE),
 389 #define DLLOFF 1
 390   {&dll, sizeof(dll), 0, "__dll__", 0, FALSE},
 391 #define MSIMAGEBASEOFF  2
 392   D(ImageBase, "___ImageBase", NT_EXE_IMAGE_BASE, TRUE),
 393   D(SectionAlignment,"__section_alignment__", PE_DEF_SECTION_ALIGNMENT, FALSE),
 394   D(FileAlignment,"__file_alignment__", PE_DEF_FILE_ALIGNMENT, FALSE),
 395   D(MajorOperatingSystemVersion,"__major_os_version__", 4, FALSE),
 396   D(MinorOperatingSystemVersion,"__minor_os_version__", 0, FALSE),
 397   D(MajorImageVersion,"__major_image_version__", 1, FALSE),
 398   D(MinorImageVersion,"__minor_image_version__", 0, FALSE),
 399 #if defined(TARGET_IS_armpe)  || defined(TARGET_IS_arm_wince_pe)
 400   D(MajorSubsystemVersion,"__major_subsystem_version__", 3, FALSE),
 401 #else
 402   D(MajorSubsystemVersion,"__major_subsystem_version__", 4, FALSE),
 403 #endif
 404   D(MinorSubsystemVersion,"__minor_subsystem_version__", 0, FALSE),
 405   D(Subsystem,"__subsystem__", ${SUBSYSTEM}, FALSE),
 406   D(SizeOfStackReserve,"__size_of_stack_reserve__", 0x200000, FALSE),
 407   D(SizeOfStackCommit,"__size_of_stack_commit__", 0x1000, FALSE),
 408   D(SizeOfHeapReserve,"__size_of_heap_reserve__", 0x100000, FALSE),
 409   D(SizeOfHeapCommit,"__size_of_heap_commit__", 0x1000, FALSE),
 410   D(LoaderFlags,"__loader_flags__", 0x0, FALSE),
 411   D(DllCharacteristics, "__dll_characteristics__", 0x0, FALSE),
 412   { NULL, 0, 0, NULL, 0 , FALSE}
 413 };
 414
 415
 416 static void
 417 gld_${EMULATION_NAME}_list_options (FILE *file)
 418 {
 419   fprintf (file, _("  --base_file <basefile>             Generate a base file for relocatable DLLs\n"));
 420   fprintf (file, _("  --dll                              Set image base to the default for DLLs\n"));
 421   fprintf (file, _("  --file-alignment <size>            Set file alignment\n"));
 422   fprintf (file, _("  --heap <size>                      Set initial size of the heap\n"));
 423   fprintf (file, _("  --image-base <address>             Set start address of the executable\n"));
 424   fprintf (file, _("  --major-image-version <number>     Set version number of the executable\n"));
 425   fprintf (file, _("  --major-os-version <number>        Set minimum required OS version\n"));
 426   fprintf (file, _("  --major-subsystem-version <number> Set minimum required OS subsystem version\n"));
 427   fprintf (file, _("  --minor-image-version <number>     Set revision number of the executable\n"));
 428   fprintf (file, _("  --minor-os-version <number>        Set minimum required OS revision\n"));
 429   fprintf (file, _("  --minor-subsystem-version <number> Set minimum required OS subsystem revision\n"));
 430   fprintf (file, _("  --section-alignment <size>         Set section alignment\n"));
 431   fprintf (file, _("  --stack <size>                     Set size of the initial stack\n"));
 432   fprintf (file, _("  --subsystem <name>[:<version>]     Set required OS subsystem [& version]\n"));
 433   fprintf (file, _("  --support-old-code                 Support interworking with old code\n"));
 434   fprintf (file, _("  --[no-]leading-underscore          Set explicit symbol underscore prefix mode\n"));
 435   fprintf (file, _("  --thumb-entry=<symbol>             Set the entry point to be Thumb <symbol>\n"));
 436 #ifdef DLL_SUPPORT
 437   fprintf (file, _("  --add-stdcall-alias                Export symbols with and without @nn\n"));
 438   fprintf (file, _("  --disable-stdcall-fixup            Don't link _sym to _sym@nn\n"));
 439   fprintf (file, _("  --enable-stdcall-fixup             Link _sym to _sym@nn without warnings\n"));
 440   fprintf (file, _("  --exclude-symbols sym,sym,...      Exclude symbols from automatic export\n"));
 441   fprintf (file, _("  --exclude-all-symbols              Exclude all symbols from automatic export\n"));
 442   fprintf (file, _("  --exclude-libs lib,lib,...         Exclude libraries from automatic export\n"));
 443   fprintf (file, _("  --exclude-modules-for-implib mod,mod,...\n"));
 444   fprintf (file, _("                                     Exclude objects, archive members from auto\n"));
 445   fprintf (file, _("                                     export, place into import library instead.\n"));
 446   fprintf (file, _("  --export-all-symbols               Automatically export all globals to DLL\n"));
 447   fprintf (file, _("  --kill-at                          Remove @nn from exported symbols\n"));
 448   fprintf (file, _("  --out-implib <file>                Generate import library\n"));
 449   fprintf (file, _("  --output-def <file>                Generate a .DEF file for the built DLL\n"));
 450   fprintf (file, _("  --warn-duplicate-exports           Warn about duplicate exports.\n"));
 451   fprintf (file, _("  --compat-implib                    Create backward compatible import libs;\n\
 452                                        create __imp_<SYMBOL> as well.\n"));
 453   fprintf (file, _("  --enable-auto-image-base           Automatically choose image base for DLLs\n\
 454                                        unless user specifies one\n"));
 455   fprintf (file, _("  --disable-auto-image-base          Do not auto-choose image base. (default)\n"));
 456   fprintf (file, _("  --dll-search-prefix=<string>       When linking dynamically to a dll without\n\
 457                                        an importlib, use <string><basename>.dll\n\
 458                                        in preference to lib<basename>.dll \n"));
 459   fprintf (file, _("  --enable-auto-import               Do sophisticated linking of _sym to\n\
 460                                        __imp_sym for DATA references\n"));
 461   fprintf (file, _("  --disable-auto-import              Do not auto-import DATA items from DLLs\n"));
 462   fprintf (file, _("  --enable-runtime-pseudo-reloc      Work around auto-import limitations by\n\
 463                                        adding pseudo-relocations resolved at\n\
 464                                        runtime.\n"));
 465   fprintf (file, _("  --disable-runtime-pseudo-reloc     Do not add runtime pseudo-relocations for\n\
 466                                        auto-imported DATA.\n"));
 467   fprintf (file, _("  --enable-extra-pe-debug            Enable verbose debug output when building\n\
 468                                        or linking to DLLs (esp. auto-import)\n"));
 469 #endif
 470   fprintf (file, _("  --large-address-aware              Executable supports virtual addresses\n\
 471                                        greater than 2 gigabytes\n"));
 472   fprintf (file, _("  --enable-long-section-names        Use long COFF section names even in\n\
 473                                        executable image files\n"));
 474   fprintf (file, _("  --disable-long-section-names       Never use long COFF section names, even\n\
 475                                        in object files\n"));
 476   fprintf (file, _("  --dynamicbase                      Image base address may be relocated using\n\
 477                                        address space layout randomization (ASLR)\n"));
 478   fprintf (file, _("  --forceinteg               Code integrity checks are enforced\n"));
 479   fprintf (file, _("  --nxcompat                 Image is compatible with data execution prevention\n"));
 480   fprintf (file, _("  --no-isolation             Image understands isolation but do not isolate the image\n"));
 481   fprintf (file, _("  --no-seh                   Image does not use SEH. No SE handler may\n\
 482                                        be called in this image\n"));
 483   fprintf (file, _("  --no-bind                  Do not bind this image\n"));
 484   fprintf (file, _("  --wdmdriver                Driver uses the WDM model\n"));
 485   fprintf (file, _("  --tsaware                  Image is Terminal Server aware\n"));
 486 }
 487
 488
 489 static void
 490 set_pe_name (char *name, long val)
 491 {
 492   int i;
 493   is_underscoring ();
 494
 495   /* Find the name and set it.  */
 496   for (i = 0; init[i].ptr; i++)
 497     {
 498       if (strcmp (name, GET_INIT_SYMBOL_NAME (i)) == 0)
 499         {
 500           init[i].value = val;
 501           init[i].inited = 1;
 502           if (strcmp (name,"__image_base__") == 0)
 503             set_pe_name (U ("__ImageBase"), val);
 504           return;
 505         }
 506     }
 507   abort ();
 508 }
 509
 510 static void
 511 set_entry_point (void)
 512 {
 513   const char *entry;
 514   const char *initial_symbol_char;
 515   int i;
 516
 517   static const struct
 518     {
 519       const int value;
 520       const char *entry;
 521     }
 522   v[] =
 523     {
 524       { 1, "NtProcessStartup"  },
 525       { 2, "WinMainCRTStartup" },
 526       { 3, "mainCRTStartup"    },
 527       { 7, "__PosixProcessStartup"},
 528       { 9, "WinMainCRTStartup" },
 529       {14, "mainCRTStartup"    },
 530       { 0, NULL          }
 531     };
 532
 533   /* Entry point name for arbitrary subsystem numbers.  */
 534   static const char default_entry[] = "mainCRTStartup";
 535
 536   if (link_info.shared || dll)
 537     {
 538 #if defined (TARGET_IS_i386pe)
 539       entry = "DllMainCRTStartup@12";
 540 #else
 541       entry = "DllMainCRTStartup";
 542 #endif
 543     }
 544   else
 545     {
 546
 547       for (i = 0; v[i].entry; i++)
 548         if (v[i].value == pe_subsystem)
 549           break;
 550
 551       /* If no match, use the default.  */
 552       if (v[i].entry != NULL)
 553         entry = v[i].entry;
 554       else
 555         entry = default_entry;
 556     }
 557
 558   initial_symbol_char = (is_underscoring () != 0 ? "_" : "");
 559
 560   if (*initial_symbol_char != '\0')
 561     {
 562       char *alc_entry;
 563
 564       /* lang_default_entry expects its argument to be permanently
 565          allocated, so we don't free this string.  */
 566       alc_entry = xmalloc (strlen (initial_symbol_char)
 567                            + strlen (entry)
 568                            + 1);
 569       strcpy (alc_entry, initial_symbol_char);
 570       strcat (alc_entry, entry);
 571       entry = alc_entry;
 572     }
 573
 574   lang_default_entry (entry);
 575 }
 576
 577 static void
 578 set_pe_subsystem (void)
 579 {
 580   const char *sver;
 581   char *end;
 582   int len;
 583   int i;
 584   unsigned long temp_subsystem;
 585   static const struct
 586     {
 587       const char *name;
 588       const int value;
 589     }
 590   v[] =
 591     {
 592       { "native",  1},
 593       { "windows", 2},
 594       { "console", 3},
 595       { "posix",   7},
 596       { "wince",   9},
 597       { "xbox",   14},
 598       { NULL, 0 }
 599     };
 600
 601   /* Check for the presence of a version number.  */
 602   sver = strchr (optarg, ':');
 603   if (sver == NULL)
 604     len = strlen (optarg);
 605   else
 606     {
 607       len = sver - optarg;
 608       set_pe_name ("__major_subsystem_version__",
 609                     strtoul (sver + 1, &end, 0));
 610       if (*end == '.')
 611         set_pe_name ("__minor_subsystem_version__",
 612                       strtoul (end + 1, &end, 0));
 613       if (*end != '\0')
 614         einfo (_("%P: warning: bad version number in -subsystem option\n"));
 615     }
 616
 617   /* Check for numeric subsystem.  */
 618   temp_subsystem = strtoul (optarg, & end, 0);
 619   if ((*end == ':' || *end == '\0') && (temp_subsystem < 65536))
 620     {
 621       /* Search list for a numeric match to use its entry point.  */
 622       for (i = 0; v[i].name; i++)
 623         if (v[i].value == (int) temp_subsystem)
 624           break;
 625
 626       /* Use this subsystem.  */
 627       pe_subsystem = (int) temp_subsystem;
 628     }
 629   else
 630     {
 631       /* Search for subsystem by name.  */
 632       for (i = 0; v[i].name; i++)
 633         if (strncmp (optarg, v[i].name, len) == 0
 634             && v[i].name[len] == '\0')
 635           break;
 636
 637       if (v[i].name == NULL)
 638         {
 639           einfo (_("%P%F: invalid subsystem type %s\n"), optarg);
 640           return;
 641         }
 642
 643       pe_subsystem = v[i].value;
 644     }
 645
 646   set_pe_name ("__subsystem__", pe_subsystem);
 647
 648   return;
 649 }
 650
 651
 652 static void
 653 set_pe_value (char *name)
 654 {
 655   char *end;
 656
 657   set_pe_name (name,  strtoul (optarg, &end, 0));
 658
 659   if (end == optarg)
 660     einfo (_("%P%F: invalid hex number for PE parameter '%s'\n"), optarg);
 661
 662   optarg = end;
 663 }
 664
 665
 666 static void
 667 set_pe_stack_heap (char *resname, char *comname)
 668 {
 669   set_pe_value (resname);
 670
 671   if (*optarg == ',')
 672     {
 673       optarg++;
 674       set_pe_value (comname);
 675     }
 676   else if (*optarg)
 677     einfo (_("%P%F: strange hex info for PE parameter '%s'\n"), optarg);
 678 }
 679
 680
 681 static bfd_boolean
 682 gld${EMULATION_NAME}_handle_option (int optc)
 683 {
 684   switch (optc)
 685     {
 686     default:
 687       return FALSE;
 688
 689     case OPTION_BASE_FILE:
 690       link_info.base_file = fopen (optarg, FOPEN_WB);
 691       if (link_info.base_file == NULL)
 692         einfo (_("%F%P: cannot open base file %s\n"), optarg);
 693       break;
 694
 695       /* PE options.  */
 696     case OPTION_HEAP:
 697       set_pe_stack_heap ("__size_of_heap_reserve__", "__size_of_heap_commit__");
 698       break;
 699     case OPTION_STACK:
 700       set_pe_stack_heap ("__size_of_stack_reserve__", "__size_of_stack_commit__");
 701       break;
 702     case OPTION_SUBSYSTEM:
 703       set_pe_subsystem ();
 704       break;
 705     case OPTION_MAJOR_OS_VERSION:
 706       set_pe_value ("__major_os_version__");
 707       break;
 708     case OPTION_MINOR_OS_VERSION:
 709       set_pe_value ("__minor_os_version__");
 710       break;
 711     case OPTION_MAJOR_SUBSYSTEM_VERSION:
 712       set_pe_value ("__major_subsystem_version__");
 713       break;
 714     case OPTION_MINOR_SUBSYSTEM_VERSION:
 715       set_pe_value ("__minor_subsystem_version__");
 716       break;
 717     case OPTION_MAJOR_IMAGE_VERSION:
 718       set_pe_value ("__major_image_version__");
 719       break;
 720     case OPTION_MINOR_IMAGE_VERSION:
 721       set_pe_value ("__minor_image_version__");
 722       break;
 723     case OPTION_FILE_ALIGNMENT:
 724       set_pe_value ("__file_alignment__");
 725       break;
 726     case OPTION_SECTION_ALIGNMENT:
 727       set_pe_value ("__section_alignment__");
 728       break;
 729     case OPTION_DLL:
 730       set_pe_name ("__dll__", 1);
 731       break;
 732     case OPTION_IMAGE_BASE:
 733       set_pe_value ("__image_base__");
 734       break;
 735     case OPTION_SUPPORT_OLD_CODE:
 736       support_old_code = 1;
 737       break;
 738     case OPTION_THUMB_ENTRY:
 739       thumb_entry_symbol = optarg;
 740       break;
 741     case OPTION_USE_NUL_PREFIXED_IMPORT_TABLES:
 742       pe_use_nul_prefixed_import_tables = TRUE;
 743       break;
 744     case OPTION_NO_LEADING_UNDERSCORE:
 745       pe_leading_underscore = 0;
 746       break;
 747     case OPTION_LEADING_UNDERSCORE:
 748       pe_leading_underscore = 1;
 749       break;
 750 #ifdef DLL_SUPPORT
 751     case OPTION_OUT_DEF:
 752       pe_out_def_filename = xstrdup (optarg);
 753       break;
 754     case OPTION_EXPORT_ALL:
 755       pe_dll_export_everything = 1;
 756       break;
 757     case OPTION_EXCLUDE_SYMBOLS:
 758       pe_dll_add_excludes (optarg, EXCLUDESYMS);
 759       break;
 760     case OPTION_EXCLUDE_ALL_SYMBOLS:
 761       pe_dll_exclude_all_symbols = 1;
 762       break;
 763     case OPTION_EXCLUDE_LIBS:
 764       pe_dll_add_excludes (optarg, EXCLUDELIBS);
 765       break;
 766     case OPTION_EXCLUDE_MODULES_FOR_IMPLIB:
 767       pe_dll_add_excludes (optarg, EXCLUDEFORIMPLIB);
 768       break;
 769     case OPTION_KILL_ATS:
 770       pe_dll_kill_ats = 1;
 771       break;
 772     case OPTION_STDCALL_ALIASES:
 773       pe_dll_stdcall_aliases = 1;
 774       break;
 775     case OPTION_ENABLE_STDCALL_FIXUP:
 776       pe_enable_stdcall_fixup = 1;
 777       break;
 778     case OPTION_DISABLE_STDCALL_FIXUP:
 779       pe_enable_stdcall_fixup = 0;
 780       break;
 781     case OPTION_IMPLIB_FILENAME:
 782       pe_implib_filename = xstrdup (optarg);
 783       break;
 784     case OPTION_WARN_DUPLICATE_EXPORTS:
 785       pe_dll_warn_dup_exports = 1;
 786       break;
 787     case OPTION_IMP_COMPAT:
 788       pe_dll_compat_implib = 1;
 789       break;
 790     case OPTION_ENABLE_AUTO_IMAGE_BASE:
 791       pe_enable_auto_image_base = 1;
 792       break;
 793     case OPTION_DISABLE_AUTO_IMAGE_BASE:
 794       pe_enable_auto_image_base = 0;
 795       break;
 796     case OPTION_DLL_SEARCH_PREFIX:
 797       pe_dll_search_prefix = xstrdup (optarg);
 798       break;
 799     case OPTION_NO_DEFAULT_EXCLUDES:
 800       pe_dll_do_default_excludes = 0;
 801       break;
 802     case OPTION_DLL_ENABLE_AUTO_IMPORT:
 803       link_info.pei386_auto_import = 1;
 804       break;
 805     case OPTION_DLL_DISABLE_AUTO_IMPORT:
 806       link_info.pei386_auto_import = 0;
 807       break;
 808     case OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC:
 809       link_info.pei386_runtime_pseudo_reloc =
 810         DEFAULT_PSEUDO_RELOC_VERSION;
 811       break;
 812     case OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V1:
 813       link_info.pei386_runtime_pseudo_reloc = 1;
 814       break;
 815     case OPTION_DLL_ENABLE_RUNTIME_PSEUDO_RELOC_V2:
 816       link_info.pei386_runtime_pseudo_reloc = 2;
 817       break;
 818     case OPTION_DLL_DISABLE_RUNTIME_PSEUDO_RELOC:
 819       link_info.pei386_runtime_pseudo_reloc = 0;
 820       break;
 821     case OPTION_ENABLE_EXTRA_PE_DEBUG:
 822       pe_dll_extra_pe_debug = 1;
 823       break;
 824 #endif
 825     case OPTION_LARGE_ADDRESS_AWARE:
 826       real_flags |= IMAGE_FILE_LARGE_ADDRESS_AWARE;
 827       break;
 828     case OPTION_ENABLE_LONG_SECTION_NAMES:
 829       pe_use_coff_long_section_names = 1;
 830       break;
 831     case OPTION_DISABLE_LONG_SECTION_NAMES:
 832       pe_use_coff_long_section_names = 0;
 833       break;
 834 /*  Get DLLCharacteristics bits  */
 835     case OPTION_DYNAMIC_BASE:
 836       pe_dll_characteristics |= IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE;
 837       break;
 838     case OPTION_FORCE_INTEGRITY:
 839       pe_dll_characteristics |= IMAGE_DLL_CHARACTERISTICS_FORCE_INTEGRITY;
 840       break;
 841     case OPTION_NX_COMPAT:
 842       pe_dll_characteristics |= IMAGE_DLL_CHARACTERISTICS_NX_COMPAT;
 843       break;
 844     case OPTION_NO_ISOLATION:
 845       pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_NO_ISOLATION;
 846       break;
 847     case OPTION_NO_SEH:
 848       pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_NO_SEH;
 849       break;
 850     case OPTION_NO_BIND:
 851       pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_NO_BIND;
 852       break;
 853     case OPTION_WDM_DRIVER:
 854       pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_WDM_DRIVER;
 855       break;
 856     case OPTION_TERMINAL_SERVER_AWARE:
 857       pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE;
 858       break;
 859     }
 860
 861   /*  Set DLLCharacteristics bits  */
 862   set_pe_name ("__dll_characteristics__", pe_dll_characteristics);
 863
 864   return TRUE;
 865 }
 866 \f
 867
 868 #ifdef DLL_SUPPORT
 869 static unsigned long
 870 strhash (const char *str)
 871 {
 872   const unsigned char *s;
 873   unsigned long hash;
 874   unsigned int c;
 875   unsigned int len;
 876
 877   hash = 0;
 878   len = 0;
 879   s = (const unsigned char *) str;
 880   while ((c = *s++) != '\0')
 881     {
 882       hash += c + (c << 17);
 883       hash ^= hash >> 2;
 884       ++len;
 885     }
 886   hash += len + (len << 17);
 887   hash ^= hash >> 2;
 888
 889   return hash;
 890 }
 891
 892 /* Use the output file to create a image base for relocatable DLLs.  */
 893
 894 static unsigned long
 895 compute_dll_image_base (const char *ofile)
 896 {
 897   unsigned long hash = strhash (ofile);
 898   return 0x61300000 + ((hash << 16) & 0x0FFC0000);
 899 }
 900 #endif
 901
 902 /* Assign values to the special symbols before the linker script is
 903    read.  */
 904
 905 static void
 906 gld_${EMULATION_NAME}_set_symbols (void)
 907 {
 908   /* Run through and invent symbols for all the
 909      names and insert the defaults.  */
 910   int j;
 911
 912   is_underscoring ();
 913
 914   if (!init[IMAGEBASEOFF].inited)
 915     {
 916       if (link_info.relocatable)
 917         init[IMAGEBASEOFF].value = 0;
 918       else if (init[DLLOFF].value || (link_info.shared && !link_info.pie))
 919         {
 920 #ifdef DLL_SUPPORT
 921           init[IMAGEBASEOFF].value = (pe_enable_auto_image_base
 922                                       ? compute_dll_image_base (output_filename)
 923                                       : NT_DLL_IMAGE_BASE);
 924 #else
 925           init[IMAGEBASEOFF].value = NT_DLL_IMAGE_BASE;
 926 #endif
 927         }
 928       else
 929         init[IMAGEBASEOFF].value = NT_EXE_IMAGE_BASE;
 930       init[MSIMAGEBASEOFF].value = init[IMAGEBASEOFF].value;
 931     }
 932
 933   /* Don't do any symbol assignments if this is a relocatable link.  */
 934   if (link_info.relocatable)
 935     return;
 936
 937   /* Glue the assignments into the abs section.  */
 938   push_stat_ptr (&abs_output_section->children);
 939
 940   for (j = 0; init[j].ptr; j++)
 941     {
 942       long val = init[j].value;
 943       lang_assignment_statement_type *rv;
 944
 945       rv = lang_add_assignment (exp_assign (GET_INIT_SYMBOL_NAME (j),
 946                                             exp_intop (val)));
 947       if (init[j].size == sizeof (short))
 948         *(short *) init[j].ptr = val;
 949       else if (init[j].size == sizeof (int))
 950         *(int *) init[j].ptr = val;
 951       else if (init[j].size == sizeof (long))
 952         *(long *) init[j].ptr = val;
 953       /* This might be a long long or other special type.  */
 954       else if (init[j].size == sizeof (bfd_vma))
 955         *(bfd_vma *) init[j].ptr = val;
 956       else      abort ();
 957       if (j == IMAGEBASEOFF)
 958         image_base_statement = rv;
 959     }
 960   /* Restore the pointer.  */
 961   pop_stat_ptr ();
 962
 963   if (pe.FileAlignment > pe.SectionAlignment)
 964     {
 965       einfo (_("%P: warning, file alignment > section alignment.\n"));
 966     }
 967 }
 968
 969 /* This is called after the linker script and the command line options
 970    have been read.  */
 971
 972 static void
 973 gld_${EMULATION_NAME}_after_parse (void)
 974 {
 975   /* PR ld/6744:  Warn the user if they have used an ELF-only
 976      option hoping it will work on PE.  */
 977   if (link_info.export_dynamic)
 978     einfo (_("%P: warning: --export-dynamic is not supported for PE "
 979       "targets, did you mean --export-all-symbols?\n"));
 980
 981   set_entry_point ();
 982
 983   after_parse_default ();
 984 }
 985
 986 /* pe-dll.c directly accesses pe_data_import_dll,
 987    so it must be defined outside of #ifdef DLL_SUPPORT.
 988    Note - this variable is deliberately not initialised.
 989    This allows it to be treated as a common varaible, and only
 990    exist in one incarnation in a multiple target enabled linker.  */
 991 char * pe_data_import_dll;
 992
 993 #ifdef DLL_SUPPORT
 994 static struct bfd_link_hash_entry *pe_undef_found_sym;
 995
 996 static bfd_boolean
 997 pe_undef_cdecl_match (struct bfd_link_hash_entry *h, void *inf)
 998 {
 999   int sl;
1000   char *string = inf;
1001   const char *hs = h->root.string;
1002
1003   sl = strlen (string);
1004   if (h->type == bfd_link_hash_defined
1005       && ((*hs == '@' && *string == '_'
1006                    && strncmp (hs + 1, string + 1, sl - 1) == 0)
1007                   || strncmp (hs, string, sl) == 0)
1008       && h->root.string[sl] == '@')
1009     {
1010       pe_undef_found_sym = h;
1011       return FALSE;
1012     }
1013   return TRUE;
1014 }
1015
1016 static void
1017 pe_fixup_stdcalls (void)
1018 {
1019   static int gave_warning_message = 0;
1020   struct bfd_link_hash_entry *undef, *sym;
1021
1022   if (pe_dll_extra_pe_debug)
1023     printf ("%s\n", __FUNCTION__);
1024
1025   for (undef = link_info.hash->undefs; undef; undef=undef->u.undef.next)
1026     if (undef->type == bfd_link_hash_undefined)
1027       {
1028         char* at = strchr (undef->root.string, '@');
1029         int lead_at = (*undef->root.string == '@');
1030         if (lead_at)
1031           at = strchr (undef->root.string + 1, '@');
1032
1033         if (at || lead_at)
1034           {
1035             /* The symbol is a stdcall symbol, so let's look for a
1036                cdecl symbol with the same name and resolve to that.  */
1037             char *cname = xstrdup (undef->root.string);
1038
1039             if (lead_at)
1040               *cname = '_';
1041             at = strchr (cname, '@');
1042             if (at)
1043               *at = 0;
1044             sym = bfd_link_hash_lookup (link_info.hash, cname, 0, 0, 1);
1045
1046             if (sym && sym->type == bfd_link_hash_defined)
1047               {
1048                 undef->type = bfd_link_hash_defined;
1049                 undef->u.def.value = sym->u.def.value;
1050                 undef->u.def.section = sym->u.def.section;
1051
1052                 if (pe_enable_stdcall_fixup == -1)
1053                   {
1054                     einfo (_("Warning: resolving %s by linking to %s\n"),
1055                            undef->root.string, cname);
1056                     if (! gave_warning_message)
1057                       {
1058                         gave_warning_message = 1;
1059                         einfo (_("Use --enable-stdcall-fixup to disable these warnings\n"));
1060                         einfo (_("Use --disable-stdcall-fixup to disable these fixups\n"));
1061                       }
1062                   }
1063               }
1064           }
1065         else
1066           {
1067             /* The symbol is a cdecl symbol, so we look for stdcall
1068                symbols - which means scanning the whole symbol table.  */
1069             pe_undef_found_sym = 0;
1070             bfd_link_hash_traverse (link_info.hash, pe_undef_cdecl_match,
1071                                     (char *) undef->root.string);
1072             sym = pe_undef_found_sym;
1073             if (sym)
1074               {
1075                 undef->type = bfd_link_hash_defined;
1076                 undef->u.def.value = sym->u.def.value;
1077                 undef->u.def.section = sym->u.def.section;
1078
1079                 if (pe_enable_stdcall_fixup == -1)
1080                   {
1081                     einfo (_("Warning: resolving %s by linking to %s\n"),
1082                            undef->root.string, sym->root.string);
1083                     if (! gave_warning_message)
1084                       {
1085                         gave_warning_message = 1;
1086                         einfo (_("Use --enable-stdcall-fixup to disable these warnings\n"));
1087                         einfo (_("Use --disable-stdcall-fixup to disable these fixups\n"));
1088                       }
1089                   }
1090               }
1091           }
1092       }
1093 }
1094
1095 static int
1096 make_import_fixup (arelent *rel, asection *s)
1097 {
1098   struct bfd_symbol *sym = *rel->sym_ptr_ptr;
1099   char addend[4];
1100
1101   if (pe_dll_extra_pe_debug)
1102     printf ("arelent: %s@%#lx: add=%li\n", sym->name,
1103             (unsigned long) rel->address, (long) rel->addend);
1104
1105   if (! bfd_get_section_contents (s->owner, s, addend, rel->address, sizeof (addend)))
1106     einfo (_("%C: Cannot get section contents - auto-import exception\n"),
1107            s->owner, s, rel->address);
1108
1109   pe_create_import_fixup (rel, s, bfd_get_32 (s->owner, addend));
1110
1111   return 1;
1112 }
1113
1114 static void
1115 pe_find_data_imports (void)
1116 {
1117   struct bfd_link_hash_entry *undef, *sym;
1118
1119   if (link_info.pei386_auto_import == 0)
1120     return;
1121
1122   for (undef = link_info.hash->undefs; undef; undef=undef->u.undef.next)
1123     {
1124       if (undef->type == bfd_link_hash_undefined)
1125         {
1126           /* C++ symbols are *long*.  */
1127           char buf[4096];
1128
1129           if (pe_dll_extra_pe_debug)
1130             printf ("%s:%s\n", __FUNCTION__, undef->root.string);
1131
1132           sprintf (buf, "__imp_%s", undef->root.string);
1133
1134           sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
1135
1136           if (sym && sym->type == bfd_link_hash_defined)
1137             {
1138               bfd *b = sym->u.def.section->owner;
1139               asymbol **symbols;
1140               int nsyms, i;
1141
1142               if (link_info.pei386_auto_import == -1)
1143                 {
1144                   static bfd_boolean warned = FALSE;
1145
1146                   info_msg (_("Info: resolving %s by linking to %s (auto-import)\n"),
1147                             undef->root.string, buf);
1148
1149                   /* PR linker/4844.  */
1150                   if (! warned)
1151                     {
1152                       warned = TRUE;
1153                       einfo (_("%P: warning: auto-importing has been activated without --enable-auto-import specified on the command line.\n\
1154 This should work unless it involves constant data structures referencing symbols from auto-imported DLLs.\n"));
1155                     }
1156                 }
1157
1158               if (!bfd_generic_link_read_symbols (b))
1159                 {
1160                   einfo (_("%B%F: could not read symbols: %E\n"), b);
1161                   return;
1162                 }
1163
1164               symbols = bfd_get_outsymbols (b);
1165               nsyms = bfd_get_symcount (b);
1166
1167               for (i = 0; i < nsyms; i++)
1168                 {
1169                   if (! CONST_STRNEQ (symbols[i]->name,
1170                                       U ("_head_")))
1171                     continue;
1172
1173                   if (pe_dll_extra_pe_debug)
1174                     printf ("->%s\n", symbols[i]->name);
1175
1176                   pe_data_import_dll = (char *) (symbols[i]->name
1177                                                  + U_SIZE ("_head_") - 1);
1178                   break;
1179                 }
1180
1181               pe_walk_relocs_of_symbol (&link_info, undef->root.string,
1182                                         make_import_fixup);
1183
1184               /* Let's differentiate it somehow from defined.  */
1185               undef->type = bfd_link_hash_defweak;
1186               /* We replace original name with __imp_ prefixed, this
1187                  1) may trash memory 2) leads to duplicate symbol generation.
1188                  Still, IMHO it's better than having name poluted.  */
1189               undef->root.string = sym->root.string;
1190               undef->u.def.value = sym->u.def.value;
1191               undef->u.def.section = sym->u.def.section;
1192             }
1193         }
1194     }
1195 }
1196
1197 static bfd_boolean
1198 pr_sym (struct bfd_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
1199 {
1200   printf ("+%s\n", h->string);
1201
1202   return TRUE;
1203 }
1204 #endif /* DLL_SUPPORT */
1205
1206 static void
1207 debug_section_p (bfd *abfd ATTRIBUTE_UNUSED, asection *sect, void *obj)
1208 {
1209   int *found = (int *) obj;
1210   if (strncmp (".debug_", sect->name, sizeof (".debug_") - 1) == 0)
1211     *found = 1;
1212 }
1213
1214 static void
1215 gld_${EMULATION_NAME}_after_open (void)
1216 {
1217   after_open_default ();
1218
1219 #ifdef DLL_SUPPORT
1220   if (pe_dll_extra_pe_debug)
1221     {
1222       bfd *a;
1223       struct bfd_link_hash_entry *sym;
1224
1225       printf ("%s()\n", __FUNCTION__);
1226
1227       for (sym = link_info.hash->undefs; sym; sym=sym->u.undef.next)
1228         printf ("-%s\n", sym->root.string);
1229       bfd_hash_traverse (&link_info.hash->table, pr_sym, NULL);
1230
1231       for (a = link_info.input_bfds; a; a = a->link_next)
1232         printf ("*%s\n",a->filename);
1233     }
1234 #endif
1235
1236   /* Pass the wacky PE command line options into the output bfd.
1237      FIXME: This should be done via a function, rather than by
1238      including an internal BFD header.  */
1239
1240   if (coff_data (link_info.output_bfd) == NULL
1241       || coff_data (link_info.output_bfd)->pe == 0)
1242     einfo (_("%F%P: cannot perform PE operations on non PE output file '%B'.\n"),
1243            link_info.output_bfd);
1244
1245   pe_data (link_info.output_bfd)->pe_opthdr = pe;
1246   pe_data (link_info.output_bfd)->dll = init[DLLOFF].value;
1247   pe_data (link_info.output_bfd)->real_flags |= real_flags;
1248
1249   /* At this point we must decide whether to use long section names
1250      in the output or not.  If the user hasn't explicitly specified
1251      on the command line, we leave it to the default for the format
1252      (object files yes, image files no), except if there is debug
1253      information present; GDB relies on the long section names to
1254      find it, so enable it in that case.  */
1255   if (pe_use_coff_long_section_names < 0 && link_info.strip == strip_none)
1256     {
1257       /* Iterate over all sections of all input BFDs, checking
1258          for any that begin 'debug_' and are long names.  */
1259       LANG_FOR_EACH_INPUT_STATEMENT (is)
1260         {
1261           int found_debug = 0;
1262           bfd_map_over_sections (is->the_bfd, debug_section_p, &found_debug);
1263           if (found_debug)
1264             {
1265               pe_use_coff_long_section_names = 1;
1266               break;
1267             }
1268         }
1269     }
1270
1271   pe_output_file_set_long_section_names (link_info.output_bfd);
1272
1273 #ifdef DLL_SUPPORT
1274   if (pe_enable_stdcall_fixup) /* -1=warn or 1=disable */
1275     pe_fixup_stdcalls ();
1276
1277   pe_process_import_defs (link_info.output_bfd, &link_info);
1278
1279   pe_find_data_imports ();
1280
1281   /* As possibly new symbols are added by imports, we rerun
1282      stdcall/fastcall fixup here.  */
1283   if (pe_enable_stdcall_fixup) /* -1=warn or 1=disable */
1284     pe_fixup_stdcalls ();
1285
1286 #if defined (TARGET_IS_i386pe) \
1287     || defined (TARGET_IS_armpe) \
1288     || defined (TARGET_IS_arm_epoc_pe) \
1289     || defined (TARGET_IS_arm_wince_pe)
1290   if (!link_info.relocatable)
1291     pe_dll_build_sections (link_info.output_bfd, &link_info);
1292 #else
1293   if (link_info.shared)
1294     pe_dll_build_sections (link_info.output_bfd, &link_info);
1295   else
1296     pe_exe_build_sections (link_info.output_bfd, &link_info);
1297 #endif
1298 #endif /* DLL_SUPPORT */
1299
1300 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe) || defined(TARGET_IS_arm_wince_pe)
1301   if (strstr (bfd_get_target (link_info.output_bfd), "arm") == NULL)
1302     {
1303       /* The arm backend needs special fields in the output hash structure.
1304          These will only be created if the output format is an arm format,
1305          hence we do not support linking and changing output formats at the
1306          same time.  Use a link followed by objcopy to change output formats.  */
1307       einfo ("%F%X%P: error: cannot change output format whilst linking ARM binaries\n");
1308       return;
1309     }
1310   {
1311     /* Find a BFD that can hold the interworking stubs.  */
1312     LANG_FOR_EACH_INPUT_STATEMENT (is)
1313       {
1314         if (bfd_arm_get_bfd_for_interworking (is->the_bfd, & link_info))
1315           break;
1316       }
1317   }
1318 #endif
1319
1320   {
1321     /* This next chunk of code tries to detect the case where you have
1322        two import libraries for the same DLL (specifically,
1323        symbolically linking libm.a and libc.a in cygwin to
1324        libcygwin.a).  In those cases, it's possible for function
1325        thunks from the second implib to be used but without the
1326        head/tail objects, causing an improper import table.  We detect
1327        those cases and rename the "other" import libraries to match
1328        the one the head/tail come from, so that the linker will sort
1329        things nicely and produce a valid import table.  */
1330
1331     LANG_FOR_EACH_INPUT_STATEMENT (is)
1332       {
1333         if (is->the_bfd->my_archive)
1334           {
1335             int idata2 = 0, reloc_count=0, is_imp = 0;
1336             asection *sec;
1337
1338             /* See if this is an import library thunk.  */
1339             for (sec = is->the_bfd->sections; sec; sec = sec->next)
1340               {
1341                 if (strcmp (sec->name, ".idata\$2") == 0)
1342                   idata2 = 1;
1343                 if (CONST_STRNEQ (sec->name, ".idata\$"))
1344                   is_imp = 1;
1345                 reloc_count += sec->reloc_count;
1346               }
1347
1348             if (is_imp && !idata2 && reloc_count)
1349               {
1350                 /* It is, look for the reference to head and see if it's
1351                    from our own library.  */
1352                 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1353                   {
1354                     int i;
1355                     long relsize;
1356                     asymbol **symbols;
1357                     arelent **relocs;
1358                     int nrelocs;
1359
1360                     relsize = bfd_get_reloc_upper_bound (is->the_bfd, sec);
1361                     if (relsize < 1)
1362                       break;
1363
1364                     if (!bfd_generic_link_read_symbols (is->the_bfd))
1365                       {
1366                         einfo (_("%B%F: could not read symbols: %E\n"),
1367                                is->the_bfd);
1368                         return;
1369                       }
1370                     symbols = bfd_get_outsymbols (is->the_bfd);
1371
1372                     relocs = xmalloc ((size_t) relsize);
1373                     nrelocs = bfd_canonicalize_reloc (is->the_bfd, sec,
1374                                                       relocs, symbols);
1375                     if (nrelocs < 0)
1376                       {
1377                         free (relocs);
1378                         einfo ("%X%P: unable to process relocs: %E\n");
1379                         return;
1380                       }
1381
1382                     for (i = 0; i < nrelocs; i++)
1383                       {
1384                         struct bfd_symbol *s;
1385                         struct bfd_link_hash_entry * blhe;
1386                         char *other_bfd_filename;
1387                         char *n;
1388
1389                         s = (relocs[i]->sym_ptr_ptr)[0];
1390
1391                         if (s->flags & BSF_LOCAL)
1392                           continue;
1393
1394                         /* Thunk section with reloc to another bfd.  */
1395                         blhe = bfd_link_hash_lookup (link_info.hash,
1396                                                      s->name,
1397                                                      FALSE, FALSE, TRUE);
1398
1399                         if (blhe == NULL
1400                             || blhe->type != bfd_link_hash_defined)
1401                           continue;
1402
1403                         other_bfd_filename
1404                           = blhe->u.def.section->owner->my_archive
1405                             ? bfd_get_filename (blhe->u.def.section->owner->my_archive)
1406                             : bfd_get_filename (blhe->u.def.section->owner);
1407
1408                         if (filename_cmp (bfd_get_filename
1409                                             (is->the_bfd->my_archive),
1410                                           other_bfd_filename) == 0)
1411                           continue;
1412
1413                         /* Rename this implib to match the other one.  */
1414                         n = xmalloc (strlen (other_bfd_filename) + 1);
1415                         strcpy (n, other_bfd_filename);
1416                         is->the_bfd->my_archive->filename = n;
1417                       }
1418
1419                     free (relocs);
1420                     /* Note - we do not free the symbols,
1421                        they are now cached in the BFD.  */
1422                   }
1423               }
1424           }
1425       }
1426   }
1427
1428   {
1429     int is_ms_arch = 0;
1430     bfd *cur_arch = 0;
1431     lang_input_statement_type *is2;
1432     lang_input_statement_type *is3;
1433
1434     /* Careful - this is a shell script.  Watch those dollar signs! */
1435     /* Microsoft import libraries have every member named the same,
1436        and not in the right order for us to link them correctly.  We
1437        must detect these and rename the members so that they'll link
1438        correctly.  There are three types of objects: the head, the
1439        thunks, and the sentinel(s).  The head is easy; it's the one
1440        with idata2.  We assume that the sentinels won't have relocs,
1441        and the thunks will.  It's easier than checking the symbol
1442        table for external references.  */
1443     LANG_FOR_EACH_INPUT_STATEMENT (is)
1444       {
1445         if (is->the_bfd->my_archive)
1446           {
1447             char *pnt;
1448             bfd *arch = is->the_bfd->my_archive;
1449
1450             if (cur_arch != arch)
1451               {
1452                 cur_arch = arch;
1453                 is_ms_arch = 1;
1454
1455                 for (is3 = is;
1456                      is3 && is3->the_bfd->my_archive == arch;
1457                      is3 = (lang_input_statement_type *) is3->next)
1458                   {
1459                     /* A MS dynamic import library can also contain static
1460                        members, so look for the first element with a .dll
1461                        extension, and use that for the remainder of the
1462                        comparisons.  */
1463                     pnt = strrchr (is3->the_bfd->filename, '.');
1464                     if (pnt != NULL && filename_cmp (pnt, ".dll") == 0)
1465                       break;
1466                   }
1467
1468                 if (is3 == NULL)
1469                   is_ms_arch = 0;
1470                 else
1471                   {
1472                     /* OK, found one.  Now look to see if the remaining
1473                        (dynamic import) members use the same name.  */
1474                     for (is2 = is;
1475                          is2 && is2->the_bfd->my_archive == arch;
1476                          is2 = (lang_input_statement_type *) is2->next)
1477                       {
1478                         /* Skip static members, ie anything with a .obj
1479                            extension.  */
1480                         pnt = strrchr (is2->the_bfd->filename, '.');
1481                         if (pnt != NULL && filename_cmp (pnt, ".obj") == 0)
1482                           continue;
1483
1484                         if (filename_cmp (is3->the_bfd->filename,
1485                                           is2->the_bfd->filename))
1486                           {
1487                             is_ms_arch = 0;
1488                             break;
1489                           }
1490                       }
1491                   }
1492               }
1493
1494             /* This fragment might have come from an .obj file in a Microsoft
1495                import, and not an actual import record. If this is the case,
1496                then leave the filename alone.  */
1497             pnt = strrchr (is->the_bfd->filename, '.');
1498
1499             if (is_ms_arch && (filename_cmp (pnt, ".dll") == 0))
1500               {
1501                 int idata2 = 0, reloc_count=0;
1502                 asection *sec;
1503                 char *new_name, seq;
1504
1505                 for (sec = is->the_bfd->sections; sec; sec = sec->next)
1506                   {
1507                     if (strcmp (sec->name, ".idata\$2") == 0)
1508                       idata2 = 1;
1509                     reloc_count += sec->reloc_count;
1510                   }
1511
1512                 if (idata2) /* .idata2 is the TOC */
1513                   seq = 'a';
1514                 else if (reloc_count > 0) /* thunks */
1515                   seq = 'b';
1516                 else /* sentinel */
1517                   seq = 'c';
1518
1519                 new_name = xmalloc (strlen (is->the_bfd->filename) + 3);
1520                 sprintf (new_name, "%s.%c", is->the_bfd->filename, seq);
1521                 is->the_bfd->filename = new_name;
1522
1523                 new_name = xmalloc (strlen (is->filename) + 3);
1524                 sprintf (new_name, "%s.%c", is->filename, seq);
1525                 is->filename = new_name;
1526               }
1527           }
1528       }
1529   }
1530
1531   {
1532     /* The following chunk of code tries to identify jump stubs in
1533        import libraries which are dead code and eliminates them
1534        from the final link. For each exported symbol <sym>, there
1535        is a object file in the import library with a .text section
1536        and several .idata\$* sections. The .text section contains the
1537        symbol definition for <sym> which is a jump stub of the form
1538        jmp *__imp_<sym>. The .idata\$5 contains the symbol definition
1539        for __imp_<sym> which is the address of the slot for <sym> in
1540        the import address table. When a symbol is imported explicitly
1541        using __declspec(dllimport) declaration, the compiler generates
1542        a reference to __imp_<sym> which directly resolves to the
1543        symbol in .idata\$5, in which case the jump stub code is not
1544        needed. The following code tries to identify jump stub sections
1545        in import libraries which are not referred to by anyone and
1546        marks them for exclusion from the final link.  */
1547     LANG_FOR_EACH_INPUT_STATEMENT (is)
1548       {
1549         if (is->the_bfd->my_archive)
1550           {
1551             int is_imp = 0;
1552             asection *sec, *stub_sec = NULL;
1553
1554             /* See if this is an import library thunk.  */
1555             for (sec = is->the_bfd->sections; sec; sec = sec->next)
1556               {
1557                 if (strncmp (sec->name, ".idata\$", 7) == 0)
1558                   is_imp = 1;
1559                 /* The section containing the jmp stub has code
1560                    and has a reloc.  */
1561                 if ((sec->flags & SEC_CODE) && sec->reloc_count)
1562                   stub_sec = sec;
1563               }
1564
1565             if (is_imp && stub_sec)
1566               {
1567                 asymbol **symbols;
1568                 long nsyms, src_count;
1569                 struct bfd_link_hash_entry * blhe;
1570
1571                 if (!bfd_generic_link_read_symbols (is->the_bfd))
1572                   {
1573                     einfo (_("%B%F: could not read symbols: %E\n"),
1574                            is->the_bfd);
1575                     return;
1576                   }
1577                 symbols = bfd_get_outsymbols (is->the_bfd);
1578                 nsyms = bfd_get_symcount (is->the_bfd);
1579
1580                 for (src_count = 0; src_count < nsyms; src_count++)
1581                   {
1582                     if (symbols[src_count]->section->id == stub_sec->id)
1583                       {
1584                         /* This symbol belongs to the section containing
1585                            the stub.  */
1586                         blhe = bfd_link_hash_lookup (link_info.hash,
1587                                                      symbols[src_count]->name,
1588                                                      FALSE, FALSE, TRUE);
1589                         /* If the symbol in the stub section has no other
1590                            undefined references, exclude the stub section
1591                            from the final link.  */
1592                         if (blhe != NULL
1593                             && blhe->type == bfd_link_hash_defined
1594                             && blhe->u.undef.next == NULL
1595                             && blhe != link_info.hash->undefs_tail)
1596                           stub_sec->flags |= SEC_EXCLUDE;
1597                       }
1598                   }
1599               }
1600           }
1601       }
1602   }
1603 }
1604 \f
1605 static void
1606 gld_${EMULATION_NAME}_before_allocation (void)
1607 {
1608 #ifdef TARGET_IS_ppcpe
1609   /* Here we rummage through the found bfds to collect toc information.  */
1610   {
1611     LANG_FOR_EACH_INPUT_STATEMENT (is)
1612       {
1613         if (!ppc_process_before_allocation (is->the_bfd, &link_info))
1614           {
1615             /* xgettext:c-format */
1616             einfo (_("Errors encountered processing file %s\n"), is->filename);
1617           }
1618       }
1619   }
1620
1621   /* We have seen it all. Allocate it, and carry on.  */
1622   ppc_allocate_toc_section (&link_info);
1623 #endif /* TARGET_IS_ppcpe */
1624
1625 #if defined(TARGET_IS_armpe) || defined(TARGET_IS_arm_epoc_pe) || defined(TARGET_IS_arm_wince_pe)
1626   /* FIXME: we should be able to set the size of the interworking stub
1627      section.
1628
1629      Here we rummage through the found bfds to collect glue
1630      information.  FIXME: should this be based on a command line
1631      option?  krk@cygnus.com.  */
1632   {
1633     LANG_FOR_EACH_INPUT_STATEMENT (is)
1634       {
1635         if (! bfd_arm_process_before_allocation
1636             (is->the_bfd, & link_info, support_old_code))
1637           {
1638             /* xgettext:c-format */
1639             einfo (_("Errors encountered processing file %s for interworking\n"),
1640                    is->filename);
1641           }
1642       }
1643   }
1644
1645   /* We have seen it all. Allocate it, and carry on.  */
1646   bfd_arm_allocate_interworking_sections (& link_info);
1647 #endif /* TARGET_IS_armpe || TARGET_IS_arm_epoc_pe || TARGET_IS_arm_wince_pe */
1648
1649   before_allocation_default ();
1650 }
1651 \f
1652 #ifdef DLL_SUPPORT
1653 /* This is called when an input file isn't recognized as a BFD.  We
1654    check here for .DEF files and pull them in automatically.  */
1655
1656 static int
1657 saw_option (char *option)
1658 {
1659   int i;
1660
1661   for (i = 0; init[i].ptr; i++)
1662     if (strcmp (GET_INIT_SYMBOL_NAME (i), option) == 0)
1663       return init[i].inited;
1664   return 0;
1665 }
1666 #endif /* DLL_SUPPORT */
1667
1668 static bfd_boolean
1669 gld_${EMULATION_NAME}_unrecognized_file (lang_input_statement_type *entry ATTRIBUTE_UNUSED)
1670 {
1671 #ifdef DLL_SUPPORT
1672   const char *ext = entry->filename + strlen (entry->filename) - 4;
1673
1674   if (filename_cmp (ext, ".def") == 0 || filename_cmp (ext, ".DEF") == 0)
1675     {
1676       pe_def_file = def_file_parse (entry->filename, pe_def_file);
1677
1678       if (pe_def_file)
1679         {
1680           int i, buflen=0, len;
1681           char *buf;
1682
1683           for (i = 0; i < pe_def_file->num_exports; i++)
1684             {
1685               len = strlen (pe_def_file->exports[i].internal_name);
1686               if (buflen < len + 2)
1687                 buflen = len + 2;
1688             }
1689
1690           buf = xmalloc (buflen);
1691
1692           for (i = 0; i < pe_def_file->num_exports; i++)
1693             {
1694               struct bfd_link_hash_entry *h;
1695
1696               sprintf (buf, "%s%s", U (""),
1697                        pe_def_file->exports[i].internal_name);
1698
1699               h = bfd_link_hash_lookup (link_info.hash, buf, TRUE, TRUE, TRUE);
1700               if (h == (struct bfd_link_hash_entry *) NULL)
1701                 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1702               if (h->type == bfd_link_hash_new)
1703                 {
1704                   h->type = bfd_link_hash_undefined;
1705                   h->u.undef.abfd = NULL;
1706                   bfd_link_add_undef (link_info.hash, h);
1707                 }
1708             }
1709           free (buf);
1710
1711           /* def_file_print (stdout, pe_def_file); */
1712           if (pe_def_file->is_dll == 1)
1713             link_info.shared = 1;
1714
1715           if (pe_def_file->base_address != (bfd_vma)(-1))
1716             {
1717               pe.ImageBase
1718                 = pe_data (link_info.output_bfd)->pe_opthdr.ImageBase
1719                 = init[IMAGEBASEOFF].value
1720                 = pe_def_file->base_address;
1721               init[IMAGEBASEOFF].inited = 1;
1722               if (image_base_statement)
1723                 image_base_statement->exp = exp_assign ("__image_base__",
1724                                                         exp_intop (pe.ImageBase));
1725             }
1726
1727           if (pe_def_file->stack_reserve != -1
1728               && ! saw_option ("__size_of_stack_reserve__"))
1729             {
1730               pe.SizeOfStackReserve = pe_def_file->stack_reserve;
1731               if (pe_def_file->stack_commit != -1)
1732                 pe.SizeOfStackCommit = pe_def_file->stack_commit;
1733             }
1734           if (pe_def_file->heap_reserve != -1
1735               && ! saw_option ("__size_of_heap_reserve__"))
1736             {
1737               pe.SizeOfHeapReserve = pe_def_file->heap_reserve;
1738               if (pe_def_file->heap_commit != -1)
1739                 pe.SizeOfHeapCommit = pe_def_file->heap_commit;
1740             }
1741           return TRUE;
1742         }
1743     }
1744 #endif
1745   return FALSE;
1746 }
1747
1748 static bfd_boolean
1749 gld_${EMULATION_NAME}_recognized_file (lang_input_statement_type *entry ATTRIBUTE_UNUSED)
1750 {
1751 #ifdef DLL_SUPPORT
1752 #ifdef TARGET_IS_i386pe
1753   pe_dll_id_target ("pei-i386");
1754 #endif
1755 #ifdef TARGET_IS_shpe
1756   pe_dll_id_target ("pei-shl");
1757 #endif
1758 #ifdef TARGET_IS_mipspe
1759   pe_dll_id_target ("pei-mips");
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) && !defined(TARGET_IS_mipspe)
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) || defined(TARGET_IS_mipspe)
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, 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, 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->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